@stigmer/runner 0.1.0-dev.20261017020314.g644422724c27

package/dist/agent-proxy/otlp-forward.js

@@ -0,0 +1,170 @@
+/**
+ * The local proxy's telemetry lane: the agent host's spans and metrics,
+ * forwarded to the operator's collector with the collector's login, which
+ * the host never holds.
+ *
+ * Why a lane: the host holds nothing the agent may not have (#2016), and a
+ * collector's login is not the agent's; for a tool like Langfuse it is a
+ * key that reads every exported conversation. So the host exports to this
+ * runner, as it reaches every other credentialed service, and the runner
+ * forwards (`server.ts`, the same door, the same host token).
+ *
+ * The host's exporters are OpenTelemetry's stock OTLP/HTTP ones
+ * (`otel-export.ts` `laneSpanExporter`), protobuf, or JSON when the operator
+ * chose `http/json`. The forward sends their body on unchanged through
+ * OpenTelemetry's own export delegates, with a serializer that returns its
+ * input, so the collector's endpoint, per-signal endpoint, path, login, TLS,
+ * compression, timeout and retry follow the standard settings exactly as the
+ * runner's own exporters do. gRPC carries the same protobuf message an HTTP
+ * export does, so a `grpc` operator's collector receives the host's bytes
+ * through the gRPC delegate as they came.
+ *
+ * Answers, in the shape the host's exporter reads: 200 with an empty export
+ * response when the collector took the batch; 503 when it did not, after
+ * the delegate's own retries, so the host's exporter retries once more
+ * inside its own bound; 404 when this runner exports no such signal; 415
+ * for a body in another encoding or compressed; 502, with a fixed sentence,
+ * when the exporter itself could not be built; 413 above
+ * {@link MAX_OTLP_BODY_BYTES}, after the body has been read to its end and
+ * dropped: the exporter streams its body, and a request cut off mid-body
+ * reads to it as a dropped connection, which it retries. A failing collector is logged when it starts
+ * failing and when it recovers, never per batch, and never a body.
+ *
+ * No live turn is required: a batch leaves the host on the span
+ * processor's schedule, often after its turn has settled. The residual is
+ * the proxy's: whoever holds the host's token can also send telemetry,
+ * which lands in the operator's collector beside the real spans; it can
+ * read nothing back and never reaches the login.
+ */
+import { laneEncoding, collectorHeaders, grpcMetadata, telemetrySettings } from "../otel-export.js";
+import { LaneRefusal } from "./lanes.js";
+import { MAX_REQUEST_BYTES } from "./relay.js";
+/**
+ * The largest body the lane accepts: the bound every lane holds the host to
+ * (`relay.ts`), there to protect the runner's memory, not to judge a batch.
+ * A batch the operator raised (`OTEL_BSP_MAX_EXPORT_BATCH_SIZE`) with content
+ * on can pass 8 MiB; dropping it whole here would hide every engine span.
+ */
+export const MAX_OTLP_BODY_BYTES = MAX_REQUEST_BYTES;
+/** The content type each lane encoding arrives in. */
+const CONTENT_TYPE = { protobuf: "application/x-protobuf", json: "application/json" };
+/** The gRPC service and method each signal's export is (the OTLP collector protos). */
+const GRPC_EXPORT = {
+    traces: { name: "TraceExportService", path: "/opentelemetry.proto.collector.trace.v1.TraceService/Export" },
+    metrics: { name: "MetricsExportService", path: "/opentelemetry.proto.collector.metrics.v1.MetricsService/Export" },
+};
+/** The path segment the lane serves each signal under, after `/v1/proxy/otlp/`. */
+const SIGNAL_PATHS = { "v1/traces": "traces", "v1/metrics": "metrics" };
+/** The signal a lane path names, or `undefined` for any other path under the lane. */
+export function otlpSignalOf(rest) {
+    return SIGNAL_PATHS[rest];
+}
+/**
+ * The request's body, or `undefined` when it passed `limit`: the rest is
+ * read and dropped rather than the socket closed, so the refusal reaches the
+ * exporter as an answer it does not retry (`relay.ts` `readBody` destroys
+ * the request, right for a model call, which nothing retries blindly).
+ */
+function readBoundedBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size <= limit)
+                chunks.push(chunk);
+            else
+                chunks.length = 0;
+        });
+        req.on("end", () => resolve(size <= limit ? Buffer.concat(chunks) : undefined));
+        req.on("error", reject);
+    });
+}
+/** The serializer that sends the host's body on as it came. */
+const PASS_THROUGH = {
+    serializeRequest: (body) => body,
+    deserializeResponse: () => ({}),
+};
+async function delegateFor(settings, signal) {
+    const protocol = settings[signal].protocol;
+    const identifier = signal === "traces" ? "TRACES" : "METRICS";
+    const headers = await collectorHeaders(signal);
+    if (protocol === "grpc") {
+        const { createOtlpGrpcExportDelegate, convertLegacyOtlpGrpcOptions } = await import("@opentelemetry/otlp-grpc-exporter-base");
+        return createOtlpGrpcExportDelegate(convertLegacyOtlpGrpcOptions({ metadata: await grpcMetadata(headers) }, identifier), PASS_THROUGH, GRPC_EXPORT[signal].name, GRPC_EXPORT[signal].path);
+    }
+    const { createOtlpHttpExportDelegate, convertLegacyHttpOptions } = await import("@opentelemetry/otlp-exporter-base/node-http");
+    return createOtlpHttpExportDelegate(convertLegacyHttpOptions({ headers }, identifier, `v1/${signal}`, { "Content-Type": CONTENT_TYPE[laneEncoding(protocol)] }), PASS_THROUGH);
+}
+/** The lane: admission, the body, the forward, the answer. Built once per proxy; delegates are built on first use. */
+export class OtlpForward {
+    settings;
+    delegates = new Map();
+    failing = new Set();
+    constructor(settings = telemetrySettings) {
+        this.settings = settings;
+    }
+    /** Serve one export the host's exporter sent; throws a {@link LaneRefusal} for a request the lane does not take. */
+    async serve(req, res, signal) {
+        if (req.method !== "POST")
+            throw new LaneRefusal(405, "an OTLP export is sent with POST");
+        const settings = this.settings();
+        if (!settings[signal].enabled)
+            throw new LaneRefusal(404, `this runner exports no ${signal}`);
+        const encoding = laneEncoding(settings[signal].protocol);
+        const contentType = (req.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase();
+        if (contentType !== CONTENT_TYPE[encoding]) {
+            throw new LaneRefusal(415, `this runner forwards ${signal} as ${CONTENT_TYPE[encoding]}, not ${contentType || "an untyped body"}`);
+        }
+        const contentEncoding = (req.headers["content-encoding"] ?? "identity").trim().toLowerCase();
+        if (contentEncoding !== "identity")
+            throw new LaneRefusal(415, "the telemetry lane takes an uncompressed body");
+        const body = await readBoundedBody(req, MAX_OTLP_BODY_BYTES);
+        if (body === undefined)
+            throw new LaneRefusal(413, `an OTLP export may carry at most ${MAX_OTLP_BODY_BYTES} bytes`);
+        const result = await this.forward(signal, body);
+        if (result.ok) {
+            res.writeHead(200, { "content-type": CONTENT_TYPE[encoding] });
+            res.end(encoding === "json" ? "{}" : "");
+            return;
+        }
+        res.writeHead(503, { "content-type": "text/plain" });
+        res.end(`the collector did not take the ${signal}: ${result.message}`);
+    }
+    /** Send one encoded export to the collector; resolves to whether it took it. */
+    async forward(signal, body) {
+        let delegate = this.delegates.get(signal);
+        if (delegate === undefined) {
+            // A delegate that could not be built is built again on the next export.
+            // Its error is never echoed: the header parser quotes a value it
+            // refuses, and the value is the collector's login.
+            delegate = delegateFor(this.settings(), signal).catch((err) => {
+                this.delegates.delete(signal);
+                console.warn(`[agent-proxy] the ${signal} exporter could not be built (${err instanceof Error ? err.name : "error"}); check the OTEL_EXPORTER_OTLP_* settings`);
+                throw new LaneRefusal(502, `this runner's ${signal} exporter could not be built`);
+            });
+            this.delegates.set(signal, delegate);
+        }
+        const ready = await delegate;
+        const { ExportResultCode } = await import("@opentelemetry/core");
+        const result = await new Promise((resolve) => ready.export(body, resolve));
+        if (result.code === ExportResultCode.SUCCESS) {
+            if (this.failing.delete(signal))
+                console.log(`[agent-proxy] the collector takes the agent host's ${signal} again`);
+            return { ok: true };
+        }
+        const message = result.error?.message ?? "the export failed";
+        if (!this.failing.has(signal)) {
+            this.failing.add(signal);
+            console.warn(`[agent-proxy] the collector refused the agent host's ${signal}: ${message}`);
+        }
+        return { ok: false, message };
+    }
+    /** Flush and close every delegate. */
+    async close() {
+        const delegates = [...this.delegates.values()];
+        this.delegates.clear();
+        await Promise.all(delegates.map(async (delegate) => (await delegate).shutdown()));
+    }
+}
+//# sourceMappingURL=otlp-forward.js.map

package/dist/agent-proxy/otlp-forward.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-forward.js","sourceRoot":"","sources":["../../src/agent-proxy/otlp-forward.ts"],"names":[],"mappings":"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"}

package/dist/agent-proxy/relay.d.ts

@@ -0,0 +1,67 @@
+/**
+ * One forwarded request: the agent host's call, re-addressed and
+ * re-credentialed by a lane (`lanes.ts`), sent upstream, and the upstream's
+ * answer streamed back unchanged.
+ *
+ * The lane is transparent by design: the host's SDK must parse the
+ * provider's own response — its status, its error body, its server-sent
+ * events or Bedrock's binary event stream — exactly as it would have
+ * talking to the provider itself, so the host's error wording and retry
+ * behaviour stay what they were. So the request keeps every header but
+ * the credential ones and the hop-by-hop ones, and the response keeps
+ * every header but the hop-by-hop ones. `accept-encoding` is pinned to
+ * `identity`, so the bytes relayed are the bytes the headers describe.
+ *
+ * The request body is buffered (a signer needs it whole; a model request
+ * is a JSON document) under {@link MAX_REQUEST_BYTES}; the response is
+ * streamed as it arrives, at the pace the host reads it. A host that disconnects aborts the upstream
+ * request; an upstream that fails mid-stream destroys the host's socket,
+ * so a cut-off answer never reads as a complete one.
+ */
+import { type IncomingHttpHeaders, type OutgoingHttpHeaders } from "node:http";
+import type { Readable } from "node:stream";
+/** The largest request body a lane accepts: the agent host's own message cap. */
+export declare const MAX_REQUEST_BYTES: number;
+export declare class RequestTooLargeError extends Error {
+}
+/** Read a request body whole, refusing one larger than `limit`. */
+export declare function readBody(req: Readable, limit?: number): Promise<Buffer>;
+/**
+ * The host's request headers a lane forwards: everything but the
+ * connection's, the host's credential, and the `x-stigmer-*` scope headers,
+ * which only the platform's proxy reads; with `keepScope`, the checked
+ * execution id still passes.
+ */
+export declare function forwardableHeaders(headers: IncomingHttpHeaders, keepScope: boolean): Record<string, string | string[]>;
+export interface Upstream {
+    readonly url: URL;
+    readonly method: string;
+    readonly headers: Record<string, string | string[]>;
+    readonly body: Buffer;
+}
+/**
+ * A response a lane answers on: HTTP/1.1's, or the HTTP/2 compatibility
+ * API's (`cursor-lane.ts`) — what both have that the lanes use.
+ */
+export interface RelayResponse extends NodeJS.WritableStream {
+    readonly headersSent: boolean;
+    readonly writableFinished: boolean;
+    writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this;
+    destroy(error?: Error): this;
+}
+/** Send `upstream` and stream its answer to `res`. Resolves when the answer has ended or failed. */
+export declare function relay(res: RelayResponse, upstream: Upstream): Promise<void>;
+/** Send `upstream` and read its whole answer: for a lane that rewrites the answer (`cursor-lane.ts`'s exchange). */
+export declare function requestWhole(upstream: Upstream): Promise<{
+    readonly status: number;
+    readonly headers: Record<string, string | string[]>;
+    readonly body: Buffer;
+}>;
+/**
+ * A refusal or a lane failure, in the shape both provider SDKs parse as an
+ * API error (`{"type":"error","error":{...}}`), so the host's classifier
+ * reads its message.
+ */
+export declare function replyError(res: RelayResponse, status: number, message: string): void;
+/** The token of an `Authorization: Bearer <token>` header, read without a backtracking pattern (the header is the host's to send). */
+export declare function bearerOf(header: string | undefined): string | undefined;

package/dist/agent-proxy/relay.js

@@ -0,0 +1,164 @@
+/**
+ * One forwarded request: the agent host's call, re-addressed and
+ * re-credentialed by a lane (`lanes.ts`), sent upstream, and the upstream's
+ * answer streamed back unchanged.
+ *
+ * The lane is transparent by design: the host's SDK must parse the
+ * provider's own response — its status, its error body, its server-sent
+ * events or Bedrock's binary event stream — exactly as it would have
+ * talking to the provider itself, so the host's error wording and retry
+ * behaviour stay what they were. So the request keeps every header but
+ * the credential ones and the hop-by-hop ones, and the response keeps
+ * every header but the hop-by-hop ones. `accept-encoding` is pinned to
+ * `identity`, so the bytes relayed are the bytes the headers describe.
+ *
+ * The request body is buffered (a signer needs it whole; a model request
+ * is a JSON document) under {@link MAX_REQUEST_BYTES}; the response is
+ * streamed as it arrives, at the pace the host reads it. A host that disconnects aborts the upstream
+ * request; an upstream that fails mid-stream destroys the host's socket,
+ * so a cut-off answer never reads as a complete one.
+ */
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+/** The largest request body a lane accepts: the agent host's own message cap. */
+export const MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+/** Headers that describe one connection, never the message (RFC 9110 §7.6.1), plus the ones the relay recomputes. */
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+    "accept-encoding",
+]);
+/** The host's credential headers: a lane replaces them, and the stigmer scope headers are the proxy's to read. */
+const HOST_CREDENTIAL = new Set(["authorization", "x-api-key"]);
+export class RequestTooLargeError extends Error {
+}
+/** Read a request body whole, refusing one larger than `limit`. */
+export function readBody(req, limit = MAX_REQUEST_BYTES) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > limit) {
+                reject(new RequestTooLargeError(`request body exceeds ${limit} bytes`));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+/**
+ * The scope header a forwarding lane passes to the platform's proxy: the
+ * execution id, which the local proxy has checked names a live turn
+ * (`server.ts`). Any other `x-stigmer-*` header the host sets is its own
+ * claim, unchecked here, and the platform authorizes and meters by those.
+ */
+const CHECKED_SCOPE = "x-stigmer-execution-id";
+/**
+ * The host's request headers a lane forwards: everything but the
+ * connection's, the host's credential, and the `x-stigmer-*` scope headers,
+ * which only the platform's proxy reads; with `keepScope`, the checked
+ * execution id still passes.
+ */
+export function forwardableHeaders(headers, keepScope) {
+    const out = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined || name.startsWith(":") || HOP_BY_HOP.has(name) || HOST_CREDENTIAL.has(name))
+            continue;
+        if (name.startsWith("x-stigmer-") && !(keepScope && name === CHECKED_SCOPE))
+            continue;
+        out[name] = value;
+    }
+    return out;
+}
+/** Send `upstream` and stream its answer to `res`. Resolves when the answer has ended or failed. */
+export function relay(res, upstream) {
+    return new Promise((resolve) => {
+        const outgoing = send(upstream);
+        const abortUpstream = () => {
+            if (!res.writableFinished)
+                outgoing.destroy();
+        };
+        res.on("close", abortUpstream);
+        outgoing.on("response", (answer) => {
+            const headers = {};
+            for (const [name, value] of Object.entries(answer.headers)) {
+                if (value !== undefined && !HOP_BY_HOP.has(name))
+                    headers[name] = value;
+            }
+            res.writeHead(answer.statusCode ?? 502, headers);
+            // Piped, so a host that reads slowly slows the provider instead of the
+            // runner buffering the stream.
+            answer.pipe(res);
+            answer.on("end", () => resolve());
+            answer.on("error", () => {
+                res.destroy();
+                resolve();
+            });
+        });
+        // Only a request that never got an answer fails here; a failure once the
+        // answer has started is the answer's own `error` above.
+        outgoing.on("error", (err) => {
+            res.off("close", abortUpstream);
+            replyError(res, 502, `the upstream could not be reached: ${err.message}`);
+            resolve();
+        });
+        outgoing.end(upstream.body);
+    });
+}
+/** Send `upstream` and read its whole answer: for a lane that rewrites the answer (`cursor-lane.ts`'s exchange). */
+export function requestWhole(upstream) {
+    return new Promise((resolve, reject) => {
+        const outgoing = send(upstream);
+        outgoing.on("response", (answer) => {
+            const headers = {};
+            for (const [name, value] of Object.entries(answer.headers)) {
+                if (value !== undefined && !HOP_BY_HOP.has(name))
+                    headers[name] = value;
+            }
+            readBody(answer).then((body) => resolve({ status: answer.statusCode ?? 502, headers, body }), reject);
+        });
+        outgoing.on("error", (err) => reject(new Error(`the upstream could not be reached: ${err.message}`)));
+        outgoing.end(upstream.body);
+    });
+}
+function send(upstream) {
+    const request = upstream.url.protocol === "https:" ? httpsRequest : httpRequest;
+    return request(upstream.url, {
+        method: upstream.method,
+        headers: { ...upstream.headers, "accept-encoding": "identity", "content-length": String(upstream.body.length) },
+    });
+}
+/**
+ * A refusal or a lane failure, in the shape both provider SDKs parse as an
+ * API error (`{"type":"error","error":{...}}`), so the host's classifier
+ * reads its message.
+ */
+export function replyError(res, status, message) {
+    if (res.headersSent) {
+        res.destroy();
+        return;
+    }
+    const body = JSON.stringify({ type: "error", error: { type: status === 401 ? "authentication_error" : "api_error", message } });
+    res.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(body)) });
+    res.end(body);
+}
+/** The token of an `Authorization: Bearer <token>` header, read without a backtracking pattern (the header is the host's to send). */
+export function bearerOf(header) {
+    if (header === undefined || !/^bearer\s/i.test(header))
+        return undefined;
+    const token = header.slice("bearer".length).trim();
+    return token.length > 0 ? token : undefined;
+}
+//# sourceMappingURL=relay.js.map

package/dist/agent-proxy/relay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.js","sourceRoot":"","sources":["../../src/agent-proxy/relay.ts"],"names":[],"mappings":"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"}

package/dist/agent-proxy/server.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The runner's local proxy: the one door through which the agent host
+ * reaches anything that needs a credential of the runner's (#2016).
+ *
+ * The host holds no key. Its model clients, its checkpoint saver and its
+ * model-registry reads all call this server on loopback with the host's
+ * token, a random value minted at each host start (`agent-host/
+ * supervisor.ts`); a lane (`lanes.ts`) swaps that token for the runner's
+ * credential and forwards the bytes (`relay.ts`). What a host token buys is
+ * bounded here, and nothing else in the runner serves the host:
+ *
+ *  - Only the current host's token is accepted, in `Authorization: Bearer`
+ *    or `x-api-key` (the two places the host's SDKs put a key), compared in
+ *    constant time.
+ *  - A model call must carry the key of a turn that is live on this runner
+ *    (`X-Stigmer-Turn-Key`), and name that turn's own execution
+ *    (`X-Stigmer-Execution-Id`). The remote adapter mints a key for each
+ *    turn, opens the turn here with it, hands it to the host with the turn,
+ *    and closes the turn when it settles (`agent-host/remote-adapter.ts`);
+ *    the host's clients stamp both headers from the turn's execution context
+ *    (`shared/execution-context.ts`). One host serves every turn of the
+ *    runner with one token, so the key is what keeps a turn to its own
+ *    execution.
+ *  - A checkpoint call must carry a live turn's key and name only that
+ *    turn's own thread (the `threadId` its engine checkpoints under), in
+ *    its query or, for a write, in every entry of its body.
+ *  - The model registry is exempt from the live-turn rule: it is the
+ *    catalog every caller may read, and the platform's proxy serves it even
+ *    to visitors.
+ *  - No lane reaches the Stigmer API beyond the registry: execution reads,
+ *    status writes, credential exchanges stay the runner's own calls.
+ *  - The Cursor SDK's traffic has a listener of its own, TLS on loopback,
+ *    under the same token and live-turn rules (`cursor-lane.ts`).
+ *  - The telemetry lane (`otlp/v1/traces`, `otlp/v1/metrics`) forwards the
+ *    host's OTLP exports to the operator's collector with the collector's
+ *    login (`otlp-forward.ts`). Like the registry it needs no live turn: a
+ *    batch leaves on the span processor's schedule, often after its turn.
+ *
+ * Every refusal is answered in the shape the providers' SDKs parse as an
+ * API error, and logged once with its reason (never a token or a body).
+ *
+ * The residual, stated plainly: while a turn is live, whoever holds the
+ * host's token can make model calls on the runner's account through this
+ * server, as the agent's engine does by design — model calls only, each
+ * lane serving its provider's inference paths and nothing else under its
+ * root (`lanes.ts`). It can no longer take a key away. And at any time it
+ * can send telemetry, which lands in the operator's collector beside the
+ * real spans; it reads nothing back and never reaches the collector's login.
+ */
+import type { Config } from "../config.js";
+import type { LiveTurnRegistry } from "../agent-host/remote-adapter.js";
+import type { AgentProxyGate } from "../agent-host/supervisor.js";
+export declare class AgentProxy implements AgentProxyGate, LiveTurnRegistry {
+    private readonly server;
+    readonly endpoint: string;
+    private readonly config;
+    private hostToken;
+    /** Live turns: each one's execution, the thread it checkpoints under, and its key. */
+    private readonly live;
+    private cursor;
+    private readonly otlp;
+    private constructor();
+    /** Listen on ephemeral loopback ports and forward with `config`'s credentials, read per request. */
+    static start(config: Config): Promise<AgentProxy>;
+    /** The Cursor lane, `https://2130706433:<port>`, 127.0.0.1 written as one number so the Cursor SDK keeps certificate checks on (`agent-proxy/cursor-lane.ts`). */
+    get cursorEndpoint(): string;
+    /** The certificate the Cursor lane serves, which the host trusts (PEM). */
+    get cursorCertificate(): string;
+    authorizeHost(token: string): void;
+    openTurn(turn: {
+        readonly executionId: string;
+        readonly threadId: string;
+        readonly turnKey: string;
+    }): () => void;
+    close(): Promise<void>;
+    private handle;
+    private authenticated;
+    private isHostToken;
+    /** The live turn whose key the request carries, compared in constant time. */
+    private liveTurnOf;
+    private requireLiveExecution;
+    /** Every thread a checkpoint call names must be its turn's own. */
+    private requireLiveThreads;
+}