@tomflow/proflow-agent-gateway 0.1.0

package/dist/deployment/descriptor.d.ts

@@ -0,0 +1,77 @@
+export declare const descriptor: {
+    readonly contract: "module";
+    readonly contractVersion: "1.0.0";
+    readonly moduleRef: "agent-gateway";
+    readonly packageName: "@tomflow/proflow-agent-gateway";
+    readonly moduleVersion: "0.1.0";
+    readonly kind: "service";
+    readonly templateVersion: "1.0.0";
+    readonly platformCompatibility: ">=1.0.0 <2.0.0";
+    readonly installClass: "core";
+    readonly identity: {
+        readonly domain: "agent-runtime-collaboration";
+        readonly summary: "The sole Custom GPT Actions HTTP ingress and OpenAI transport anti-corruption layer.";
+    };
+    readonly provides: readonly [{
+        readonly contractRef: "custom-gpt-actions-gateway";
+        readonly version: "1.0.0";
+    }];
+    readonly requires: readonly [{
+        readonly contractRef: "agent-runtime";
+        readonly versionRange: ">=1.0.0 <2.0.0";
+    }, {
+        readonly contractRef: "task-orchestration";
+        readonly versionRange: ">=1.0.0 <2.0.0";
+    }, {
+        readonly contractRef: "execution";
+        readonly versionRange: ">=1.0.0 <2.0.0";
+    }];
+    readonly requirements: readonly [{
+        readonly kind: "runtime";
+        readonly runtime: "node";
+        readonly versionRange: ">=24.19.0";
+    }];
+    readonly configSlots: readonly [{
+        readonly key: "localBaseUrl";
+        readonly type: "url";
+        readonly required: true;
+        readonly description: "Loopback HTTP listener URL owned by Agent Gateway and targeted by the public ingress resource";
+    }, {
+        readonly key: "publicBaseUrl";
+        readonly type: "url";
+        readonly required: true;
+        readonly description: "Public HTTPS URL supplied by the dev-tunnel resource";
+    }, {
+        readonly key: "downstreamCredentialFile";
+        readonly type: "path";
+        readonly required: true;
+        readonly sensitive: true;
+        readonly description: "File containing the dedicated Gateway-to-platform-host transport credential";
+    }, {
+        readonly key: "publicIngressModuleRef";
+        readonly type: "moduleRef";
+        readonly required: false;
+        readonly description: "External resource module governing the public ingress";
+        readonly default: "dev-tunnel";
+    }];
+    readonly lifecycle: {
+        readonly supported: readonly ["describe", "preflight", "status", "verify", "doctor", "start", "stop", "restart", "uninstall"];
+    };
+    readonly verification: {
+        readonly checks: readonly [{
+            readonly id: "gateway-readiness";
+            readonly description: "Gateway dependencies and transport guards are ready";
+            readonly lifecycle: "verify";
+        }];
+    };
+    readonly effects: readonly [{
+        readonly kind: "process";
+        readonly description: "Manage the declared service process";
+        readonly retention: "remove";
+    }];
+    readonly documentation: readonly [{
+        readonly id: "overview";
+        readonly path: "./README.md";
+        readonly description: "Agent Gateway package overview";
+    }];
+};

package/dist/deployment/descriptor.js

@@ -0,0 +1,88 @@
+export const descriptor = {
+    contract: "module",
+    contractVersion: "1.0.0",
+    moduleRef: "agent-gateway",
+    packageName: "@tomflow/proflow-agent-gateway",
+    moduleVersion: "0.1.0",
+    kind: "service",
+    templateVersion: "1.0.0",
+    platformCompatibility: ">=1.0.0 <2.0.0",
+    installClass: "core",
+    identity: {
+        domain: "agent-runtime-collaboration",
+        summary: "The sole Custom GPT Actions HTTP ingress and OpenAI transport anti-corruption layer.",
+    },
+    provides: [{ contractRef: "custom-gpt-actions-gateway", version: "1.0.0" }],
+    requires: [
+        { contractRef: "agent-runtime", versionRange: ">=1.0.0 <2.0.0" },
+        { contractRef: "task-orchestration", versionRange: ">=1.0.0 <2.0.0" },
+        { contractRef: "execution", versionRange: ">=1.0.0 <2.0.0" },
+    ],
+    requirements: [
+        { kind: "runtime", runtime: "node", versionRange: ">=24.19.0" },
+    ],
+    configSlots: [
+        {
+            key: "localBaseUrl",
+            type: "url",
+            required: true,
+            description: "Loopback HTTP listener URL owned by Agent Gateway and targeted by the public ingress resource",
+        },
+        {
+            key: "publicBaseUrl",
+            type: "url",
+            required: true,
+            description: "Public HTTPS URL supplied by the dev-tunnel resource",
+        },
+        {
+            key: "downstreamCredentialFile",
+            type: "path",
+            required: true,
+            sensitive: true,
+            description: "File containing the dedicated Gateway-to-platform-host transport credential",
+        },
+        {
+            key: "publicIngressModuleRef",
+            type: "moduleRef",
+            required: false,
+            description: "External resource module governing the public ingress",
+            default: "dev-tunnel",
+        },
+    ],
+    lifecycle: {
+        supported: [
+            "describe",
+            "preflight",
+            "status",
+            "verify",
+            "doctor",
+            "start",
+            "stop",
+            "restart",
+            "uninstall",
+        ],
+    },
+    verification: {
+        checks: [
+            {
+                id: "gateway-readiness",
+                description: "Gateway dependencies and transport guards are ready",
+                lifecycle: "verify",
+            },
+        ],
+    },
+    effects: [
+        {
+            kind: "process",
+            description: "Manage the declared service process",
+            retention: "remove",
+        },
+    ],
+    documentation: [
+        {
+            id: "overview",
+            path: "./README.md",
+            description: "Agent Gateway package overview",
+        },
+    ],
+};

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { createAgentGatewayProcess, loadAgentGatewayProcessConfig, } from "./process.js";
+function installSelf() {
+    const executable = process.platform === "win32" ? "npx.cmd" : "npx";
+    const result = spawnSync(executable, [
+        "--yes",
+        "@tomflow/proflow-platform-cli",
+        "install",
+        "@tomflow/proflow-agent-gateway",
+    ], { cwd: process.cwd(), env: process.env, stdio: "inherit" });
+    if (result.error)
+        throw result.error;
+    process.exit(result.status ?? 1);
+}
+async function main() {
+    const [command, configPath] = process.argv.slice(2);
+    if (command === "--help" || command === "-h") {
+        process.stdout.write("Usage: proflow-agent-gateway install | start /absolute/config.json\\n");
+        process.exit(0);
+    }
+    if (command === "install") {
+        if (configPath)
+            throw new Error("Usage: proflow-agent-gateway install");
+        installSelf();
+    }
+    if (command !== "start" || !configPath)
+        throw new Error("Usage: proflow-agent-gateway start /absolute/config.json");
+    const config = await loadAgentGatewayProcessConfig(configPath);
+    if (!config.downstreamCredentialFile)
+        throw new Error("agent-gateway requires downstreamCredentialFile for authenticated platform-host transport");
+    const processService = await createAgentGatewayProcess({
+        config,
+        log: (entry) => process.stderr.write(`${JSON.stringify(entry)}\n`),
+    });
+    const address = await processService.start();
+    process.stdout.write(`${JSON.stringify({ status: "RUNNING", ...address })}\n`);
+    let stopping = false;
+    const stop = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        void processService.stop().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    await new Promise(() => { });
+}
+if (import.meta.main) {
+    await main();
+}

package/dist/src/index.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+export interface ExternalFileMaterializationInput {
+    name: string;
+    provenanceRef: string;
+    declaredMimeType: string;
+    sourceUrl: string;
+}
+export type GatewayOwnerPorts = {
+    authenticateBearer(credential: string): Promise<string>;
+    route(operationId: string, authenticatedRoleRef: string, input: unknown, context?: {
+        signal: AbortSignal;
+        fileMaterializationInputs?: readonly ExternalFileMaterializationInput[];
+    }): Promise<unknown>;
+    lookupResult?(operationId: string, authenticatedRoleRef: string, input: unknown): Promise<unknown>;
+    readiness(): Promise<Record<string, boolean>>;
+};
+export type GatewayOptions = {
+    owners: GatewayOwnerPorts;
+    relayBaseUrl: string;
+    host?: string;
+    port?: number;
+    now?: () => number;
+    actionTimeoutMs?: number;
+};
+export declare class AgentGatewayError extends Error {
+    readonly code: string;
+    constructor(code: string, message?: string);
+}
+declare const fileInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    mime_type: z.ZodString;
+    download_link: z.ZodURL;
+}, z.core.$strict>;
+type FileInput = z.infer<typeof fileInputSchema>;
+type RelayArtifact = {
+    artifactRef: string;
+    name: string;
+    mimeType: string;
+    bytes: Buffer;
+};
+declare const ownerFileBridgeArtifactSchema: z.ZodObject<{
+    artifactRef: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type OwnerFileBridgeArtifact = z.infer<typeof ownerFileBridgeArtifactSchema>;
+declare const ownerFileBridgeOutputSchema: z.ZodObject<{
+    fileArtifacts: z.ZodArray<z.ZodObject<{
+        artifactRef: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OwnerFileBridgeOutput = z.infer<typeof ownerFileBridgeOutputSchema>;
+export declare function createAgentGateway(options: GatewayOptions): Promise<Readonly<{
+    start: () => Promise<{
+        host: string;
+        port: number;
+    }>;
+    stop: () => Promise<void>;
+    restart: () => Promise<{
+        host: string;
+        port: number;
+    }>;
+    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) => FileInput[];
+    createRelay: (artifact: RelayArtifact) => {
+        token: string;
+        url: string;
+    };
+    readRelay: (token: string, method: string, artifactRef?: string) => Promise<{
+        body: Buffer<ArrayBufferLike>;
+        headers: {
+            "content-type": string;
+            "content-disposition": string;
+        };
+    }>;
+    serializeFileResponse: (raw: RelayArtifact[]) => {
+        openaiFileResponse: Record<string, string>[];
+    };
+    businessPersistence: readonly never[];
+}>>;
+export {};