@tomflow/proflow-agent-gateway 0.1.0

package/dist/src/index.js

@@ -0,0 +1,430 @@
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { isIP } from "node:net";
+import { z } from "zod";
+const MAX_ACTION_CHARS = 100_000;
+const MAX_INPUT_FILES = 10;
+const MAX_FILE_BYTES = 10_000_000;
+const RELAY_TTL_MS = 300_000;
+export class AgentGatewayError extends Error {
+    code;
+    constructor(code, message = code) {
+        super(`${code}: ${message}`);
+        this.code = code;
+    }
+}
+const fileInputSchema = z
+    .object({
+    name: z.string().min(1),
+    id: z.string().min(1),
+    mime_type: z.string().min(1),
+    download_link: z.url(),
+})
+    .strict();
+const actionSchema = z
+    .object({
+    operationId: z.string().min(1),
+    body: z.record(z.string(), z.unknown()).default({}),
+    uncertain: z.boolean().optional(),
+})
+    .strict();
+const ownerFileBridgeArtifactSchema = z.object({
+    artifactRef: z.string().min(1),
+    name: z.string().min(1),
+    mimeType: z.string().min(1),
+    content: z.string().min(1),
+});
+const ownerFileBridgeOutputSchema = z.object({
+    fileArtifacts: z.array(ownerFileBridgeArtifactSchema).max(MAX_INPUT_FILES),
+});
+// Only this explicit allowed operation may produce the typed File Bridge
+// descriptor. Any other owner output that happens to carry a same-named
+// `fileArtifacts` key is treated as ordinary JSON and never reaches the
+// GPT-facing `openaiFileResponse` serializer.
+const FILE_BRIDGE_OUTPUT_OPERATIONS = new Set([
+    "getTaskDocument",
+]);
+function safeFilename(name) {
+    return (name.length > 0 &&
+        name !== "." &&
+        name !== ".." &&
+        !/[\\/]/.test(name) &&
+        ![...name].some((character) => {
+            const code = character.codePointAt(0) ?? 0;
+            return code < 32 || code === 127;
+        }) &&
+        !name.includes(".."));
+}
+function privateIpv4(host) {
+    const parts = host.split(".").map(Number);
+    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part)))
+        return false;
+    return (parts[0] === 0 ||
+        parts[0] === 10 ||
+        parts[0] === 127 ||
+        (parts[0] === 100 && (parts[1] ?? 0) >= 64 && (parts[1] ?? 0) <= 127) ||
+        (parts[0] === 169 && parts[1] === 254) ||
+        (parts[0] === 172 && (parts[1] ?? 0) >= 16 && (parts[1] ?? 0) <= 31) ||
+        (parts[0] === 192 && parts[1] === 168) ||
+        (parts[0] === 198 && (parts[1] === 18 || parts[1] === 19)) ||
+        (parts[0] ?? 0) >= 224);
+}
+export async function createAgentGateway(options) {
+    const now = options.now ?? Date.now;
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 0;
+    let server;
+    let lifecycle = "STOPPED";
+    let inFlight = 0;
+    const relays = new Map();
+    const assertSafeRemoteUrl = (raw) => {
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            throw new AgentGatewayError("OPENAI_FILE_INPUT_INVALID");
+        }
+        const hostname = url.hostname.toLowerCase();
+        if (url.protocol !== "https:" ||
+            hostname === "localhost" ||
+            hostname === "metadata.google.internal" ||
+            privateIpv4(hostname) ||
+            (isIP(hostname) === 6 &&
+                (hostname === "::1" ||
+                    hostname.startsWith("fe80:") ||
+                    hostname.startsWith("fc") ||
+                    hostname.startsWith("fd"))))
+            throw new AgentGatewayError("OPENAI_FILE_INPUT_INVALID");
+        return url;
+    };
+    const normalizeFileInputs = (raw) => {
+        const list = z.array(fileInputSchema).parse(raw);
+        if (list.length > MAX_INPUT_FILES)
+            throw new AgentGatewayError("OPENAI_FILE_COUNT_EXCEEDED");
+        for (const item of list) {
+            if (!safeFilename(item.name))
+                throw new AgentGatewayError("OPENAI_FILE_INPUT_INVALID");
+            assertSafeRemoteUrl(item.download_link);
+        }
+        return list;
+    };
+    const createRelay = (artifact) => {
+        if (!safeFilename(artifact.name))
+            throw new AgentGatewayError("OPENAI_FILE_INPUT_INVALID");
+        if (/^(image|video)\//.test(artifact.mimeType))
+            throw new AgentGatewayError("OPENAI_FILE_RESPONSE_UNSUPPORTED_MEDIA");
+        if (artifact.bytes.length > MAX_FILE_BYTES)
+            throw new AgentGatewayError("OPENAI_FILE_RESPONSE_TOO_LARGE");
+        const token = randomBytes(32).toString("base64url");
+        relays.set(token, { ...artifact, expiresAt: now() + RELAY_TTL_MS });
+        const url = new URL(encodeURIComponent(token), options.relayBaseUrl);
+        return {
+            token,
+            url: url.href,
+        };
+    };
+    const readRelay = async (token, method, artifactRef) => {
+        const relay = relays.get(token);
+        if (!relay || relay.expiresAt < now())
+            throw new AgentGatewayError("OPENAI_FILE_RELAY_EXPIRED");
+        if (method !== "GET" ||
+            (artifactRef !== undefined && relay.artifactRef !== artifactRef))
+            throw new AgentGatewayError("OPENAI_FILE_RELAY_SCOPE_INVALID");
+        return {
+            body: relay.bytes,
+            headers: {
+                "content-type": relay.mimeType,
+                "content-disposition": `attachment; filename="${relay.name}"`,
+            },
+        };
+    };
+    const serializeFileResponse = (raw) => {
+        const artifacts = z
+            .array(z.object({
+            artifactRef: z.string().min(1),
+            name: z.string().min(1),
+            mimeType: z.string().min(1),
+            bytes: z.instanceof(Buffer),
+        }))
+            .parse(raw);
+        if (artifacts.length > MAX_INPUT_FILES)
+            throw new AgentGatewayError("OPENAI_FILE_COUNT_EXCEEDED");
+        for (const artifact of artifacts) {
+            if (!safeFilename(artifact.name))
+                throw new AgentGatewayError("OPENAI_FILE_INPUT_INVALID");
+            if (/^(image|video)\//.test(artifact.mimeType))
+                throw new AgentGatewayError("OPENAI_FILE_RESPONSE_UNSUPPORTED_MEDIA");
+            if (artifact.bytes.length > MAX_FILE_BYTES)
+                throw new AgentGatewayError("OPENAI_FILE_RESPONSE_TOO_LARGE");
+        }
+        const items = artifacts.map((artifact) => ({
+            kind: "inline",
+            name: artifact.name,
+            mime_type: artifact.mimeType,
+            content: artifact.bytes.toString("base64"),
+        }));
+        for (let index = artifacts.length - 1; index >= 0; index -= 1) {
+            const candidate = { openaiFileResponse: items };
+            if (JSON.stringify(candidate).length < MAX_ACTION_CHARS)
+                return candidate;
+            const artifact = artifacts[index];
+            if (!artifact)
+                continue;
+            const relay = createRelay(artifact);
+            items[index] = {
+                kind: "url",
+                name: artifact.name,
+                mime_type: artifact.mimeType,
+                download_link: relay.url,
+            };
+        }
+        const candidate = { openaiFileResponse: items };
+        if (JSON.stringify(candidate).length >= MAX_ACTION_CHARS)
+            throw new AgentGatewayError("OPENAI_ACTION_RESPONSE_BUDGET_EXCEEDED");
+        return candidate;
+    };
+    const ownerFileBridgeOutput = (operationId, output) => {
+        if (!FILE_BRIDGE_OUTPUT_OPERATIONS.has(operationId))
+            return undefined;
+        if (typeof output !== "object" || output === null || Array.isArray(output))
+            return undefined;
+        if (!("fileArtifacts" in output))
+            return undefined;
+        const parsed = ownerFileBridgeOutputSchema.parse(output);
+        return parsed.fileArtifacts.map((item) => ({
+            artifactRef: item.artifactRef,
+            name: item.name,
+            mimeType: item.mimeType,
+            bytes: Buffer.from(item.content, "utf8"),
+        }));
+    };
+    const readiness = async () => {
+        const checks = await options.owners.readiness();
+        // Intrinsic Gateway capabilities are verified here rather than trusting the
+        // owner to report them: ingress is the real accepting/bound socket state, and
+        // relay requires a valid HTTPS base URL that an external client can fetch.
+        let relayReady = false;
+        try {
+            relayReady = new URL(options.relayBaseUrl).protocol === "https:";
+        }
+        catch {
+            relayReady = false;
+        }
+        const merged = {
+            ...checks,
+            ingress: lifecycle === "RUNNING" && server !== undefined,
+            relay: relayReady && checks.relay !== false,
+        };
+        return {
+            status: Object.values(merged).every(Boolean)
+                ? "READY"
+                : "NOT_READY",
+            checks: merged,
+        };
+    };
+    const handler = async (request, response) => {
+        inFlight += 1;
+        try {
+            const url = new URL(request.url ?? "/", `http://${host}`);
+            if (request.method === "GET" && url.pathname === "/health") {
+                response.setHeader("content-type", "application/json; charset=utf-8");
+                response.setHeader("cache-control", "no-store");
+                response.end(JSON.stringify({ status: "UP" }));
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/ready") {
+                const state = await readiness();
+                response.statusCode = state.status === "READY" ? 200 : 503;
+                response.setHeader("content-type", "application/json; charset=utf-8");
+                response.setHeader("cache-control", "no-store");
+                response.end(JSON.stringify(state));
+                return;
+            }
+            if (url.pathname.startsWith("/relay/")) {
+                if (request.method !== "GET" || url.search !== "") {
+                    response.statusCode = 404;
+                    response.end();
+                    return;
+                }
+                try {
+                    const relay = await readRelay(decodeURIComponent(url.pathname.slice("/relay/".length)), request.method);
+                    response.setHeader("cache-control", "private, no-store");
+                    response.setHeader("x-content-type-options", "nosniff");
+                    for (const [name, value] of Object.entries(relay.headers))
+                        response.setHeader(name, value);
+                    response.end(relay.body);
+                }
+                catch {
+                    response.statusCode = 404;
+                    response.end();
+                }
+                return;
+            }
+            response.setHeader("content-type", "application/json; charset=utf-8");
+            const authorization = request.headers.authorization;
+            if (!authorization?.startsWith("Bearer ")) {
+                response.statusCode = 401;
+                response.end(JSON.stringify({ error: "AUTHENTICATION_FAILED" }));
+                return;
+            }
+            let authenticatedRoleRef;
+            try {
+                authenticatedRoleRef = await options.owners.authenticateBearer(authorization.slice("Bearer ".length));
+            }
+            catch {
+                response.statusCode = 401;
+                response.end(JSON.stringify({ error: "AUTHENTICATION_FAILED" }));
+                return;
+            }
+            let action;
+            if (request.method === "GET" && url.pathname.startsWith("/actions/")) {
+                action = {
+                    operationId: decodeURIComponent(url.pathname.slice("/actions/".length)),
+                    body: Object.fromEntries(url.searchParams),
+                };
+            }
+            else if (request.method === "POST" &&
+                (url.pathname === "/actions" || url.pathname.startsWith("/actions/"))) {
+                const chunks = [];
+                let chars = 0;
+                for await (const chunk of request) {
+                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    chars += buffer.toString("utf8").length;
+                    if (chars >= MAX_ACTION_CHARS) {
+                        response.statusCode = 413;
+                        response.end(JSON.stringify({
+                            error: "OPENAI_ACTION_REQUEST_BUDGET_EXCEEDED",
+                        }));
+                        return;
+                    }
+                    chunks.push(buffer);
+                }
+                const parsedBody = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                action = actionSchema.parse(url.pathname === "/actions"
+                    ? parsedBody
+                    : {
+                        operationId: decodeURIComponent(url.pathname.slice("/actions/".length)),
+                        body: parsedBody,
+                    });
+            }
+            else {
+                response.statusCode = 404;
+                response.end(JSON.stringify({ error: "NOT_FOUND" }));
+                return;
+            }
+            const { roleRef: _untrustedRoleRef, openaiFileIdRefs: rawFileInputs, ...canonicalBody } = action.body;
+            const fileMaterializationInputs = rawFileInputs === undefined
+                ? undefined
+                : normalizeFileInputs(rawFileInputs).map((file) => ({
+                    name: file.name,
+                    provenanceRef: file.id,
+                    declaredMimeType: file.mime_type,
+                    sourceUrl: file.download_link,
+                }));
+            if (fileMaterializationInputs !== undefined) {
+                if (action.operationId !== "putTaskDocument")
+                    throw new AgentGatewayError("OPENAI_FILE_INPUT_UNSUPPORTED_OPERATION");
+                if (fileMaterializationInputs.length !== 1)
+                    throw new AgentGatewayError("OPENAI_FILE_COUNT_EXCEEDED");
+                if (typeof canonicalBody.content === "string" &&
+                    canonicalBody.content.length > 0)
+                    throw new AgentGatewayError("OPENAI_FILE_INPUT_CONFLICT");
+            }
+            const actionSignal = AbortSignal.timeout(options.actionTimeoutMs ?? 45_000);
+            const operation = action.uncertain && options.owners.lookupResult
+                ? options.owners.lookupResult(action.operationId, authenticatedRoleRef, canonicalBody)
+                : options.owners.route(action.operationId, authenticatedRoleRef, canonicalBody, {
+                    signal: actionSignal,
+                    ...(fileMaterializationInputs === undefined
+                        ? {}
+                        : { fileMaterializationInputs }),
+                });
+            const output = await Promise.race([
+                operation,
+                new Promise((_resolve, reject) => actionSignal.addEventListener("abort", () => reject(Object.assign(new AgentGatewayError("OPENAI_ACTION_TIMEOUT"), {
+                    httpStatus: 504,
+                })), { once: true })),
+            ]);
+            const fileArtifacts = ownerFileBridgeOutput(action.operationId, output);
+            if (fileArtifacts !== undefined) {
+                response.end(JSON.stringify(serializeFileResponse(fileArtifacts)));
+                return;
+            }
+            const serialized = JSON.stringify(output);
+            if (serialized.length >= MAX_ACTION_CHARS) {
+                response.statusCode = 500;
+                response.end(JSON.stringify({ error: "OPENAI_ACTION_RESPONSE_BUDGET_EXCEEDED" }));
+                return;
+            }
+            response.end(serialized);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError || error instanceof SyntaxError) {
+                response.statusCode = 400;
+                response.end(JSON.stringify({ error: "INVALID_REQUEST" }));
+                return;
+            }
+            const requestedStatus = error && typeof error === "object" && "httpStatus" in error
+                ? Number(error.httpStatus)
+                : 500;
+            response.statusCode =
+                Number.isInteger(requestedStatus) &&
+                    requestedStatus >= 400 &&
+                    requestedStatus <= 599
+                    ? requestedStatus
+                    : 500;
+            response.end(JSON.stringify({
+                error: error instanceof AgentGatewayError ? error.code : "GATEWAY_FAILURE",
+            }));
+        }
+        finally {
+            inFlight -= 1;
+        }
+    };
+    const start = async () => {
+        if (server)
+            throw new AgentGatewayError("SERVICE_ALREADY_RUNNING");
+        server = createServer((request, response) => void handler(request, response));
+        await new Promise((resolve, reject) => {
+            server?.once("error", reject);
+            server?.listen(port, host, resolve);
+        });
+        const address = server.address();
+        if (!address || typeof address === "string")
+            throw new AgentGatewayError("SERVICE_START_FAILED");
+        lifecycle = "RUNNING";
+        return { host, port: address.port };
+    };
+    const stop = async () => {
+        const active = server;
+        server = undefined;
+        if (!active)
+            return;
+        lifecycle = "DRAINING";
+        await new Promise((resolve, reject) => active.close((error) => (error ? reject(error) : resolve())));
+        lifecycle = "STOPPED";
+    };
+    const restart = async () => {
+        await stop();
+        return start();
+    };
+    return Object.freeze({
+        start,
+        stop,
+        restart,
+        readiness,
+        status: () => ({
+            process: lifecycle,
+            liveness: lifecycle === "STOPPED" ? "DOWN" : "UP",
+            accepting: lifecycle === "RUNNING",
+            inFlight,
+        }),
+        assertSafeRemoteUrl,
+        normalizeFileInputs,
+        createRelay,
+        readRelay,
+        serializeFileResponse,
+        businessPersistence: Object.freeze([]),
+    });
+}

package/dist/src/process.d.ts

@@ -0,0 +1,70 @@
+export type AgentGatewayProcessConfig = {
+    host: string;
+    port: number;
+    publicBaseUrl: string;
+    downstreamBaseUrl: string;
+    credentialFile: string;
+    downstreamCredentialFile?: string;
+};
+export declare function parseAgentGatewayProcessConfig(value: unknown): AgentGatewayProcessConfig;
+export declare function loadAgentGatewayProcessConfig(path: string): Promise<AgentGatewayProcessConfig>;
+export declare function createAgentGatewayProcess(input: {
+    config: AgentGatewayProcessConfig;
+    fetch?: typeof globalThis.fetch;
+    log?: (entry: Record<string, unknown>) => void;
+}): Promise<Readonly<{
+    readiness: () => Promise<{
+        status: "NOT_READY" | "READY";
+        checks: {
+            ingress: boolean;
+            relay: boolean;
+        };
+    }>;
+    status: () => {
+        process: "DRAINING" | "RUNNING" | "STOPPED";
+        liveness: "DOWN" | "UP";
+        accepting: boolean;
+        inFlight: number;
+    };
+    assertSafeRemoteUrl: (raw: string) => URL;
+    normalizeFileInputs: (raw: unknown) => {
+        name: string;
+        id: string;
+        mime_type: string;
+        download_link: string;
+    }[];
+    createRelay: (artifact: {
+        artifactRef: string;
+        name: string;
+        mimeType: string;
+        bytes: Buffer;
+    }) => {
+        token: string;
+        url: string;
+    };
+    readRelay: (token: string, method: string, artifactRef?: string) => Promise<{
+        body: Buffer<ArrayBufferLike>;
+        headers: {
+            "content-type": string;
+            "content-disposition": string;
+        };
+    }>;
+    serializeFileResponse: (raw: {
+        artifactRef: string;
+        name: string;
+        mimeType: string;
+        bytes: Buffer;
+    }[]) => {
+        openaiFileResponse: Record<string, string>[];
+    };
+    businessPersistence: readonly never[];
+    start: () => Promise<{
+        host: string;
+        port: number;
+    }>;
+    stop: () => Promise<void>;
+    restart(): Promise<{
+        host: string;
+        port: number;
+    }>;
+}>>;

package/dist/src/process.js

@@ -0,0 +1,193 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createAgentGateway } from "./index.js";
+function record(value, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new TypeError(`${name} must be an object`);
+    return value;
+}
+function text(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new TypeError(`${name} must be a non-empty string`);
+    return value;
+}
+export function parseAgentGatewayProcessConfig(value) {
+    const input = record(value, "agent-gateway config");
+    const publicBaseUrl = new URL(text(input.publicBaseUrl, "publicBaseUrl"));
+    if (publicBaseUrl.protocol !== "https:")
+        throw new TypeError("publicBaseUrl must be HTTPS");
+    const downstreamBaseUrl = new URL(text(input.downstreamBaseUrl, "downstreamBaseUrl"));
+    if (downstreamBaseUrl.protocol !== "http:" ||
+        !["localhost", "127.0.0.1", "::1"].includes(downstreamBaseUrl.hostname))
+        throw new TypeError("downstreamBaseUrl must be loopback HTTP");
+    const port = input.port === undefined ? 0 : Number(input.port);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535)
+        throw new TypeError("port must be an integer from 0 through 65535");
+    return {
+        host: input.host === undefined ? "127.0.0.1" : text(input.host, "host"),
+        port,
+        publicBaseUrl: publicBaseUrl.href.replace(/\/$/, ""),
+        downstreamBaseUrl: downstreamBaseUrl.href.replace(/\/$/, ""),
+        credentialFile: resolve(text(input.credentialFile, "credentialFile")),
+        ...(input.downstreamCredentialFile === undefined
+            ? {}
+            : {
+                downstreamCredentialFile: resolve(text(input.downstreamCredentialFile, "downstreamCredentialFile")),
+            }),
+    };
+}
+export async function loadAgentGatewayProcessConfig(path) {
+    return parseAgentGatewayProcessConfig(JSON.parse(await readFile(resolve(path), "utf8")));
+}
+function sameSecret(left, right) {
+    const a = createHash("sha256").update(left).digest();
+    const b = createHash("sha256").update(right).digest();
+    return timingSafeEqual(a, b);
+}
+function parseCredentialStore(value) {
+    const store = record(value, "credential store");
+    const credentials = {};
+    for (const [roleRef, credential] of Object.entries(store)) {
+        if (roleRef.length === 0 ||
+            typeof credential !== "string" ||
+            credential.length < 16)
+            throw new TypeError("credential store contains an invalid role credential");
+        credentials[roleRef] = credential;
+    }
+    return credentials;
+}
+async function readCurrentCredentialStore(file) {
+    return parseCredentialStore(JSON.parse(await readFile(file, "utf8")));
+}
+async function readDownstreamCredential(file) {
+    const info = await stat(file);
+    if (process.platform !== "win32" && (info.mode & 0o077) !== 0)
+        throw new Error("DOWNSTREAM_TRANSPORT_CREDENTIAL_PERMISSIONS_INVALID");
+    const credential = (await readFile(file, "utf8")).trim();
+    if (credential.length < 32)
+        throw new Error("DOWNSTREAM_TRANSPORT_CREDENTIAL_INVALID");
+    return credential;
+}
+export async function createAgentGatewayProcess(input) {
+    const fetchImplementation = input.fetch ?? globalThis.fetch;
+    const credentialFile = input.config.credentialFile;
+    // Fail-fast at startup so a malformed configured credential store is rejected
+    // before the process advertises readiness. Authentication re-reads the current
+    // store on every attempt below, so a rotated key takes effect without a restart
+    // and a malformed/half-written store fails closed instead of serving a stale
+    // snapshot.
+    await readCurrentCredentialStore(credentialFile);
+    if (input.config.downstreamCredentialFile)
+        await readDownstreamCredential(input.config.downstreamCredentialFile);
+    const credentialAuthority = async () => {
+        try {
+            return (Object.keys(await readCurrentCredentialStore(credentialFile)).length > 0);
+        }
+        catch {
+            return false;
+        }
+    };
+    const downstream = async (path, body, signal) => {
+        const downstreamCredential = input.config.downstreamCredentialFile
+            ? await readDownstreamCredential(input.config.downstreamCredentialFile)
+            : undefined;
+        const response = await fetchImplementation(`${input.config.downstreamBaseUrl}${path}`, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                ...(body === undefined ? {} : { "content-type": "application/json" }),
+                ...(downstreamCredential
+                    ? { authorization: `Bearer ${downstreamCredential}` }
+                    : {}),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            ...(signal ? { signal } : {}),
+        });
+        if (!response.ok)
+            throw Object.assign(new Error("DOWNSTREAM_UNAVAILABLE"), {
+                httpStatus: response.status,
+            });
+        return response.json();
+    };
+    const gateway = await createAgentGateway({
+        host: input.config.host,
+        port: input.config.port,
+        relayBaseUrl: `${input.config.publicBaseUrl}/relay/`,
+        owners: {
+            async authenticateBearer(credential) {
+                const credentials = await readCurrentCredentialStore(credentialFile);
+                for (const [roleRef, stored] of Object.entries(credentials))
+                    if (sameSecret(credential, String(stored)))
+                        return roleRef;
+                throw new Error("AUTHENTICATION_FAILED");
+            },
+            route(operationId, authenticatedRoleRef, value, context) {
+                return downstream(`/actions/${encodeURIComponent(operationId)}`, {
+                    authenticatedRoleRef,
+                    input: value,
+                    ...(context?.fileMaterializationInputs === undefined
+                        ? {}
+                        : {
+                            fileMaterializationInputs: context.fileMaterializationInputs,
+                        }),
+                }, context?.signal);
+            },
+            lookupResult(operationId, authenticatedRoleRef, value) {
+                return downstream(`/actions/${encodeURIComponent(operationId)}/result`, {
+                    authenticatedRoleRef,
+                    input: value,
+                });
+            },
+            async readiness() {
+                try {
+                    const downstreamCredential = input.config.downstreamCredentialFile
+                        ? await readDownstreamCredential(input.config.downstreamCredentialFile)
+                        : undefined;
+                    const response = await fetchImplementation(`${input.config.downstreamBaseUrl}/ready`, {
+                        headers: downstreamCredential
+                            ? { authorization: `Bearer ${downstreamCredential}` }
+                            : {},
+                        signal: AbortSignal.timeout(2_000),
+                    });
+                    return {
+                        credentialStore: await credentialAuthority(),
+                        downstream: response.ok,
+                    };
+                }
+                catch {
+                    return {
+                        credentialStore: await credentialAuthority(),
+                        downstream: false,
+                    };
+                }
+            },
+        },
+    });
+    const start = async () => {
+        const address = await gateway.start();
+        input.log?.({
+            timestamp: new Date().toISOString(),
+            component: "agent-gateway-process",
+            event: "SERVICE_STARTED",
+            ...address,
+        });
+        return address;
+    };
+    const stop = async () => {
+        await gateway.stop();
+        input.log?.({
+            timestamp: new Date().toISOString(),
+            component: "agent-gateway-process",
+            event: "SERVICE_STOPPED",
+        });
+    };
+    return Object.freeze({
+        ...gateway,
+        start,
+        stop,
+        async restart() {
+            await stop();
+            return start();
+        },
+    });
+}