@gatebolt/agent-redroom 0.1.0

package/dist/sidecar/fake-web.js

@@ -0,0 +1,87 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createServer as createHttpServer, } from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import {} from "../types.js";
+import { isFakeHost } from "./dns.js";
+import { headersOf, SCAN_LIMIT, sourceIp } from "./state.js";
+const run = promisify(execFile);
+const HIT_BODY_LIMIT = 64 * 1024;
+export async function generateTls(domain) {
+    const dir = await mkdtemp(join(tmpdir(), "redroom-tls-"));
+    const f = (name) => join(dir, name);
+    const openssl = (...args) => run("openssl", args);
+    try {
+        await writeFile(f("ext.cnf"), `subjectAltName=DNS:*.${domain},DNS:${domain}\nbasicConstraints=CA:FALSE\nextendedKeyUsage=serverAuth\n`);
+        await openssl(...["req", "-x509", "-newkey", "rsa:2048", "-nodes"], ...["-keyout", f("ca.key"), "-out", f("ca.pem"), "-days", "2"], ...["-subj", "/CN=agent-redroom fake web CA"]);
+        await openssl(...["req", "-newkey", "rsa:2048", "-nodes"], ...["-keyout", f("srv.key"), "-out", f("srv.csr")], ...["-subj", `/CN=*.${domain}`]);
+        await openssl(...["x509", "-req", "-in", f("srv.csr")], ...["-CA", f("ca.pem"), "-CAkey", f("ca.key"), "-CAcreateserial"], ...["-out", f("srv.pem"), "-days", "2", "-extfile", f("ext.cnf")]);
+        const [caPem, certPem, keyPem] = await Promise.all([
+            readFile(f("ca.pem"), "utf8"),
+            readFile(f("srv.pem"), "utf8"),
+            readFile(f("srv.key"), "utf8"),
+        ]);
+        return { caPem, certPem, keyPem };
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+function fakeWeb(context, protocol) {
+    return (req, res) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            if (size < SCAN_LIMIT)
+                chunks.push(chunk);
+            size += chunk.length;
+        });
+        req.on("end", () => {
+            const host = (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
+            if (!isFakeHost(host, context.domain)) {
+                res.writeHead(404).end();
+                return;
+            }
+            const target = req.url ?? "/";
+            const url = URL.parse(target, "http://fake-web");
+            const source = sourceIp(req, context.trustTestSourceHeader);
+            const method = req.method ?? "GET";
+            const path = url ? url.pathname + url.search : target;
+            const body = Buffer.concat(chunks);
+            context.state.recordHit(source, {
+                protocol,
+                host,
+                method,
+                path,
+                headers: headersOf(req),
+                body: body.subarray(0, HIT_BODY_LIMIT).toString("utf8"),
+                truncated: size > HIT_BODY_LIMIT,
+            }, body.toString("utf8"));
+            if (!url) {
+                res.writeHead(400, { "Content-Type": "text/plain" }).end("bad request");
+                return;
+            }
+            const pages = context.state.runForIp(source)?.pages ?? {};
+            const page = pages[`${host}${path}`] ?? pages[`${host}${url.pathname}`];
+            if (page) {
+                res.writeHead(page.status, { "Content-Type": page.contentType });
+                res.end(page.body);
+                return;
+            }
+            if (method === "GET" || method === "HEAD") {
+                res.writeHead(404, { "Content-Type": "text/plain" }).end("not found");
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/plain" }).end("ok");
+        });
+    };
+}
+export function createFakeHttps(context, tls) {
+    return createHttpsServer({ cert: tls.certPem, key: tls.keyPem }, fakeWeb(context, "https"));
+}
+export function createFakeHttp(context) {
+    return createHttpServer(fakeWeb(context, "http"));
+}

package/dist/sidecar/http.d.ts

@@ -0,0 +1,9 @@
+import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+export declare const BODY_LIMIT_BYTES: number;
+export declare class BodyTooLargeError extends Error {
+}
+export declare function readBody(body: AsyncIterable<Uint8Array>, limit?: number): Promise<Buffer>;
+export declare function readJson(req: IncomingMessage): Promise<unknown>;
+export declare function sendJson(res: ServerResponse, status: number, body: unknown, headers?: Record<string, string>): void;
+export declare function bearerMatches(header: string | undefined, secret: string): boolean;
+export declare function jsonServer(handle: (req: IncomingMessage, res: ServerResponse) => Promise<void>): Server;

package/dist/sidecar/http.js

@@ -0,0 +1,37 @@
+import { timingSafeEqual } from "node:crypto";
+import { createServer, } from "node:http";
+export const BODY_LIMIT_BYTES = 1024 * 1024;
+export class BodyTooLargeError extends Error {
+}
+export async function readBody(body, limit = BODY_LIMIT_BYTES) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of body) {
+        size += chunk.length;
+        if (size > limit)
+            throw new BodyTooLargeError("body too large");
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+export async function readJson(req) {
+    return JSON.parse((await readBody(req)).toString("utf8"));
+}
+export function sendJson(res, status, body, headers = {}) {
+    res.writeHead(status, { "Content-Type": "application/json", ...headers });
+    res.end(JSON.stringify(body));
+}
+export function bearerMatches(header, secret) {
+    const given = Buffer.from(header ?? "");
+    const wanted = Buffer.from(`Bearer ${secret}`);
+    return given.length === wanted.length && timingSafeEqual(given, wanted);
+}
+export function jsonServer(handle) {
+    return createServer((req, res) => {
+        handle(req, res).catch(() => {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        });
+    });
+}

package/dist/sidecar/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sidecar/main.js

@@ -0,0 +1,22 @@
+import { CONFIG_ENV, configSchema, PORTS } from "./config.js";
+import { startSidecar } from "./sidecar.js";
+const raw = process.env[CONFIG_ENV];
+if (!raw)
+    throw new Error(`${CONFIG_ENV} is required`);
+const config = configSchema.parse(JSON.parse(raw));
+const sidecar = await startSidecar({
+    controlSecret: config.controlSecret,
+    domain: config.domain,
+    ports: PORTS,
+    lease: { ms: config.leaseMs, onExpired: () => shutdown() },
+});
+function shutdown() {
+    void sidecar.stop().then(() => process.exit(0));
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+function keepRunning(error) {
+    console.error("sidecar: unexpected error, still running:", error);
+}
+process.on("uncaughtException", keepRunning);
+process.on("unhandledRejection", keepRunning);

package/dist/sidecar/relay.d.ts

@@ -0,0 +1,9 @@
+import { type Server } from "node:http";
+import { type SidecarState } from "./state.js";
+export declare const UPSTREAM_IDLE_TIMEOUT_MS = 120000;
+export type RelayContext = {
+    state: SidecarState;
+    trustTestSourceHeader: boolean;
+    idleTimeoutMs: number;
+};
+export declare function createRelay(context: RelayContext): Server;

package/dist/sidecar/relay.js

@@ -0,0 +1,174 @@
+import { createServer, request as httpRequest, } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { findSecrets } from "../secrets.js";
+import { DETAIL_LIMIT } from "../types.js";
+import { headerLines, headersOf, push, SCAN_LIMIT, sourceIp, } from "./state.js";
+// Well under the turn timeout so a silent proxy is cut and logged first; streams send pings.
+export const UPSTREAM_IDLE_TIMEOUT_MS = 120_000;
+const DROPPED = new Set([
+    "host",
+    "connection",
+    "authorization",
+    "x-api-key",
+    "x-redroom-run",
+    "accept-encoding",
+]);
+const MODEL_ENDPOINTS = new Set([
+    "POST /v1/messages",
+    "POST /v1/messages/count_tokens",
+    "GET /v1/models",
+]);
+function forwardedHeaders(headers, upstream, runId) {
+    const kept = Object.fromEntries(Object.entries(headers).filter(([name]) => !DROPPED.has(name)));
+    return { ...kept, ...upstream.headers, "x-redroom-run": runId };
+}
+function isLocalPath(path) {
+    return path.startsWith("/") && !path.startsWith("//");
+}
+function isModelEndpoint(method, path) {
+    const { pathname } = new URL(path, "http://relay");
+    return MODEL_ENDPOINTS.has(`${method} ${pathname}`);
+}
+function upstreamUrl(baseUrl, path) {
+    const base = new URL(baseUrl);
+    const request = new URL(path, base.origin);
+    const target = new URL(base.origin);
+    target.pathname = base.pathname.replace(/\/$/, "") + request.pathname;
+    target.search = request.search;
+    return target;
+}
+function refuseEndpoint(run, method, path, res) {
+    push(run.modelCalls, {
+        method,
+        path,
+        status: 403,
+        durationMs: 0,
+        requestBytes: 0,
+        at: new Date().toISOString(),
+        secrets: [],
+        error: {
+            by: "sidecar",
+            code: "path_not_allowed",
+            detail: "the relay forwards only the model endpoints",
+        },
+    });
+    res.writeHead(403, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "path not allowed" }));
+}
+export function createRelay(context) {
+    return createServer((req, res) => {
+        try {
+            relay(context, req, res);
+        }
+        catch {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        }
+    });
+}
+function relay(context, req, res) {
+    const path = req.url ?? "/";
+    if (!isLocalPath(path)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "request target must be a path" }));
+        return;
+    }
+    const entry = context.state.runEntryForIp(sourceIp(req, context.trustTestSourceHeader));
+    if (!entry) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "unknown source" }));
+        return;
+    }
+    const [runId, run] = entry;
+    const method = req.method ?? "GET";
+    if (!isModelEndpoint(method, path)) {
+        refuseEndpoint(run, method, path, res);
+        return;
+    }
+    const target = upstreamUrl(run.modelProxy.baseUrl, path);
+    const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const started = Date.now();
+    const scanned = [];
+    let requestBytes = 0;
+    let status = 0;
+    let errorBody = "";
+    let error;
+    let recorded = false;
+    const record = () => {
+        if (recorded)
+            return;
+        recorded = true;
+        const body = Buffer.concat(scanned).toString("utf8");
+        const text = [path, headerLines(headersOf(req)), body].join("\n");
+        if (!error && status >= 400) {
+            error = {
+                by: "modelProxy",
+                code: `http_${status}`,
+                detail: errorBody.slice(0, DETAIL_LIMIT),
+                call: { url: target.href, status, durationMs: Date.now() - started },
+            };
+        }
+        push(run.modelCalls, {
+            method,
+            path,
+            status,
+            durationMs: Date.now() - started,
+            requestBytes,
+            at: new Date(started).toISOString(),
+            secrets: findSecrets(text, run.secrets),
+            ...(error ? { error } : {}),
+        });
+    };
+    const fail = (code, detail) => {
+        if (recorded)
+            return;
+        error = {
+            by: "modelProxy",
+            code,
+            detail,
+            call: { url: target.href, durationMs: Date.now() - started },
+        };
+        if (res.headersSent) {
+            res.destroy();
+        }
+        else {
+            status = code === "timeout" ? 504 : 502;
+            res.writeHead(status, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "model proxy unreachable" }));
+        }
+        record();
+    };
+    req.on("data", (chunk) => {
+        if (requestBytes < SCAN_LIMIT)
+            scanned.push(chunk);
+        requestBytes += chunk.length;
+    });
+    const out = send(target, {
+        method,
+        headers: forwardedHeaders(req.headers, run.modelProxy, runId),
+        // Set as an option, not with out.setTimeout(), so it also covers the connect.
+        timeout: context.idleTimeoutMs,
+    }, (answer) => {
+        status = answer.statusCode ?? 502;
+        res.writeHead(status, answer.headers);
+        answer.on("data", (chunk) => {
+            if (status >= 400 && errorBody.length < DETAIL_LIMIT) {
+                errorBody += chunk.toString("utf8");
+            }
+        });
+        answer.on("error", (cause) => fail("upstream_aborted", cause.message));
+        answer.pipe(res);
+    });
+    out.on("timeout", () => {
+        fail("timeout", `model proxy sent nothing for ${context.idleTimeoutMs} ms`);
+        out.destroy();
+    });
+    out.on("error", (cause) => fail("network_error", cause.message));
+    res.on("close", () => {
+        if (!res.writableFinished)
+            out.destroy();
+        record();
+    });
+    req.pipe(out);
+}

package/dist/sidecar/sidecar.d.ts

@@ -0,0 +1,24 @@
+import { type SidecarPorts } from "./config.js";
+import { type Ips } from "./dns.js";
+import { SidecarState } from "./state.js";
+export type SidecarOptions = {
+    controlSecret: string;
+    domain: string;
+    ports: SidecarPorts;
+    ips?: Ips;
+    host?: string;
+    trustTestSourceHeader?: boolean;
+    fetch?: typeof fetch;
+    checkTimeoutMs?: number;
+    upstreamIdleTimeoutMs?: number;
+    lease?: {
+        ms: number;
+        onExpired: () => void;
+    };
+};
+export type Sidecar = {
+    ports: SidecarPorts;
+    state: SidecarState;
+    stop(): Promise<void>;
+};
+export declare function startSidecar(options: SidecarOptions): Promise<Sidecar>;

package/dist/sidecar/sidecar.js

@@ -0,0 +1,106 @@
+import {} from "node:dgram";
+import {} from "node:http";
+import { networkInterfaces } from "node:os";
+import {} from "./config.js";
+import { createControl } from "./control.js";
+import { createDns } from "./dns.js";
+import { createFakeHttp, createFakeHttps, generateTls } from "./fake-web.js";
+import { createRelay, UPSTREAM_IDLE_TIMEOUT_MS } from "./relay.js";
+import { SidecarState } from "./state.js";
+import { CHECK_TIMEOUT_MS, createToolHook } from "./tool-hook.js";
+function ownIps() {
+    const [first = "127.0.0.1", ...rest] = Object.values(networkInterfaces())
+        .flatMap((addrs) => addrs ?? [])
+        .filter((addr) => addr.family === "IPv4" && !addr.internal)
+        .map((addr) => addr.address);
+    return [first, ...rest];
+}
+const listen = (server, port, host) => new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+        const address = server.address();
+        resolve(typeof address === "object" && address ? address.port : port);
+    });
+});
+const listenUdp = (socket, port, host) => new Promise((resolve, reject) => {
+    socket.once("error", reject);
+    socket.bind(port, host, () => {
+        socket.on("error", () => undefined);
+        resolve(socket.address().port);
+    });
+});
+const close = (server) => new Promise((resolve) => {
+    server.close(() => resolve());
+    server.closeAllConnections();
+});
+export async function startSidecar(options) {
+    const state = new SidecarState();
+    const host = options.host ?? "0.0.0.0";
+    const trustTestSourceHeader = options.trustTestSourceHeader ?? false;
+    const { domain } = options;
+    const tls = await generateTls(domain);
+    const controller = new AbortController();
+    let renewedAt = Date.now();
+    const lease = options.lease;
+    const leaseTimer = lease
+        ? setInterval(() => {
+            if (Date.now() - renewedAt > lease.ms)
+                lease.onExpired();
+        }, Math.max(1, Math.floor(lease.ms / 4)))
+        : undefined;
+    leaseTimer?.unref();
+    const web = { state, domain, trustTestSourceHeader };
+    const servers = {
+        http: createFakeHttp(web),
+        https: createFakeHttps(web, tls),
+        relay: createRelay({
+            state,
+            trustTestSourceHeader,
+            idleTimeoutMs: options.upstreamIdleTimeoutMs ?? UPSTREAM_IDLE_TIMEOUT_MS,
+        }),
+        hook: createToolHook({
+            state,
+            fetch: options.fetch ?? fetch,
+            signal: controller.signal,
+            trustTestSourceHeader,
+            timeoutMs: options.checkTimeoutMs ?? CHECK_TIMEOUT_MS,
+        }),
+        control: createControl({
+            state,
+            secret: options.controlSecret,
+            caPem: tls.caPem,
+            renew: () => {
+                renewedAt = Date.now();
+            },
+        }),
+    };
+    const { ips } = options;
+    const dns = createDns({ state, domain }, ips ? () => ips : ownIps);
+    const all = Object.values(servers);
+    try {
+        const ports = {
+            dns: await listenUdp(dns, options.ports.dns, host),
+            http: await listen(servers.http, options.ports.http, host),
+            https: await listen(servers.https, options.ports.https, host),
+            relay: await listen(servers.relay, options.ports.relay, host),
+            hook: await listen(servers.hook, options.ports.hook, host),
+            control: await listen(servers.control, options.ports.control, host),
+        };
+        return {
+            ports,
+            state,
+            async stop() {
+                clearInterval(leaseTimer);
+                controller.abort();
+                dns.close();
+                await Promise.all(all.map((server) => close(server)));
+            },
+        };
+    }
+    catch (error) {
+        clearInterval(leaseTimer);
+        dns.close();
+        await Promise.all(all.filter((server) => server.listening).map((server) => close(server)));
+        throw error;
+    }
+}

package/dist/sidecar/state.d.ts

@@ -0,0 +1,45 @@
+import { type IncomingMessage } from "node:http";
+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;
+export declare const SCAN_LIMIT: number;
+export type ServedPage = {
+    body: string;
+    contentType: string;
+    status: number;
+};
+export type Log<T> = {
+    entries: T[];
+    dropped: number;
+    bytes: number;
+    /** The secret matches of each entry, at the entry's index. */
+    matches: SecretMatch[][];
+    holders: Map<string, number>;
+};
+type Entry = Hit | ToolCall | ModelCall;
+export type RunState = {
+    ip: string;
+    pages: Record<string, ServedPage>;
+    secrets: Secrets;
+    modelProxy: ModelProxy;
+    toolCallCheck?: ToolCallCheck | undefined;
+    hits: Log<Hit>;
+    toolCalls: Log<ToolCall>;
+    modelCalls: Log<ModelCall>;
+};
+export declare const normalizeIp: (address: string | undefined) => string;
+export declare function sourceIp(req: IncomingMessage, trustTestSourceHeader: boolean): string;
+export declare const headersOf: (req: IncomingMessage) => Record<string, string>;
+export declare const headerLines: (headers: Record<string, string>) => string;
+/** Evicts oldest entries past the caps, but keeps one per secret match so a flood cannot erase evidence. */
+export declare function push<T extends Entry>(log: Log<T>, entry: T, matches?: SecretMatch[]): void;
+export declare function drain<T>(log: Log<T>): Log<T>;
+export declare class SidecarState {
+    readonly runs: Map<string, RunState>;
+    readonly unattributed: Log<Hit>;
+    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;
+    recordHit(ip: string, hit: Omit<Hit, "at" | "secrets">, scannedBody?: string): void;
+}
+export {};

package/dist/sidecar/state.js

@@ -0,0 +1,93 @@
+import {} from "node:http";
+import { findSecrets } from "../secrets.js";
+import {} from "../types.js";
+export const MAX_ENTRIES = 10_000;
+export const MAX_LOG_BYTES = 4 * 1024 * 1024;
+export const SCAN_LIMIT = 16 * 1024 * 1024;
+export const normalizeIp = (address) => (address ?? "").replace(/^::ffff:/, "");
+export function sourceIp(req, trustTestSourceHeader) {
+    const testSource = req.headers["x-test-source-ip"];
+    return trustTestSourceHeader && typeof testSource === "string"
+        ? testSource
+        : normalizeIp(req.socket.remoteAddress);
+}
+export const headersOf = (req) => Object.fromEntries(Object.entries(req.headersDistinct).map(([name, values = []]) => [
+    name,
+    values.join(", "),
+]));
+export const headerLines = (headers) => Object.entries(headers)
+    .map(([name, value]) => `${name}: ${value}`)
+    .join("\n");
+const emptyLog = () => ({
+    entries: [],
+    dropped: 0,
+    bytes: 0,
+    matches: [],
+    holders: new Map(),
+});
+const sizeOf = (entry) => Buffer.byteLength(JSON.stringify(entry));
+const keyOf = (match) => `${match.secret}:${match.encoding}`;
+const isOverCap = (log) => log.entries.length > MAX_ENTRIES || log.bytes > MAX_LOG_BYTES;
+const countHolders = (log, matches, by) => {
+    for (const match of matches) {
+        const key = keyOf(match);
+        log.holders.set(key, (log.holders.get(key) ?? 0) + by);
+    }
+};
+const isRedundant = (log, matches) => matches.every((match) => log.holders.get(keyOf(match)) !== 1);
+/** Evicts oldest entries past the caps, but keeps one per secret match so a flood cannot erase evidence. */
+export function push(log, entry, matches = "secrets" in entry ? entry.secrets : []) {
+    log.entries.push(entry);
+    log.matches.push(matches);
+    log.bytes += sizeOf(entry);
+    countHolders(log, matches, 1);
+    while (isOverCap(log)) {
+        const index = log.matches.findIndex((held) => isRedundant(log, held));
+        if (index === -1)
+            break;
+        const [evicted] = log.entries.splice(index, 1);
+        const [evictedMatches = []] = log.matches.splice(index, 1);
+        if (evicted)
+            log.bytes -= sizeOf(evicted);
+        countHolders(log, evictedMatches, -1);
+        log.dropped += 1;
+    }
+}
+export function drain(log) {
+    const drained = { ...log };
+    Object.assign(log, emptyLog());
+    return drained;
+}
+export class SidecarState {
+    runs = new Map();
+    unattributed = emptyLog();
+    register(id, run) {
+        if (this.runs.has(id))
+            return "run";
+        if (this.runForIp(run.ip))
+            return "ip";
+        this.runs.set(id, {
+            ...run,
+            hits: emptyLog(),
+            toolCalls: emptyLog(),
+            modelCalls: emptyLog(),
+        });
+        return "ok";
+    }
+    runEntryForIp(ip) {
+        return [...this.runs].find(([, run]) => run.ip === ip);
+    }
+    runForIp(ip) {
+        return this.runEntryForIp(ip)?.[1];
+    }
+    recordHit(ip, hit, scannedBody = hit.body) {
+        const run = this.runForIp(ip);
+        const headers = headerLines(hit.headers ?? {});
+        const text = [hit.host, hit.path, headers, scannedBody].join("\n");
+        push(run?.hits ?? this.unattributed, {
+            ...hit,
+            at: new Date().toISOString(),
+            secrets: run ? findSecrets(text, run.secrets) : [],
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { type Server } from "node:http";
+import { type ToolCall } from "../types.js";
+import { type SidecarState } from "./state.js";
+export declare const CHECK_TIMEOUT_MS = 25000;
+export declare function actionOf(response: unknown): ToolCall["action"];
+export type ToolHookContext = {
+    state: SidecarState;
+    fetch: typeof fetch;
+    signal: AbortSignal;
+    trustTestSourceHeader: boolean;
+    timeoutMs: number;
+};
+export declare function createToolHook(context: ToolHookContext): Server;