@wardby/cli 0.7.0 → 0.9.0

package/dist/native-worker/ledger.d.ts

@@ -115,11 +115,15 @@ export declare class PrismaGatewayLedger {
     setDelegation(sessionId: string, callId: string, state: {
         status: "pending" | "waiting_budget";
         childAgentId: string;
+        childRepository?: string;
         childRunId?: string;
     }): Promise<void>;
     delegation(sessionId: string, callId: string): Promise<DelegationState | null>;
-    /** The sub-agents other delegations of this run are waiting for budget to start. */
-    waitingChildAgentIds(sessionId: string, exceptCallId: string): Promise<string[]>;
+    /** The sub-agents (and repositories, null = the child's default) other delegations of this run wait on budget to start. */
+    waitingDelegations(sessionId: string, exceptCallId: string): Promise<{
+        childAgentId: string;
+        childRepository: string | null;
+    }[]>;
     /** Delegations of this session whose child run is started and not yet reported. */
     openDelegationChildren(sessionId: string): Promise<string[]>;
 }

package/dist/native-worker/ledger.js

@@ -202,6 +202,7 @@ export class PrismaGatewayLedger {
             data: {
                 status: state.status,
                 childAgentId: state.childAgentId,
+                ...(state.childRepository ? { childRepository: state.childRepository } : {}),
                 ...(state.childRunId ? { childRunId: state.childRunId } : {}),
             },
         });
@@ -213,13 +214,13 @@ export class PrismaGatewayLedger {
         const status = row.status === "waiting_budget" ? "waiting_budget" : row.status === "completed" ? "completed" : "pending";
         return { status, childRunId: row.childRunId, childAgentId: row.childAgentId, createdAt: row.createdAt };
     }
-    /** The sub-agents other delegations of this run are waiting for budget to start. */
-    async waitingChildAgentIds(sessionId, exceptCallId) {
+    /** The sub-agents (and repositories, null = the child's default) other delegations of this run wait on budget to start. */
+    async waitingDelegations(sessionId, exceptCallId) {
         const rows = await this.db.nativeGatewayCall.findMany({
             where: { sessionId, status: "waiting_budget", callId: { not: exceptCallId }, childAgentId: { not: null } },
-            select: { childAgentId: true },
+            select: { childAgentId: true, childRepository: true },
         });
-        return rows.map((row) => row.childAgentId);
+        return rows.map((row) => ({ childAgentId: row.childAgentId, childRepository: row.childRepository }));
     }
     /** Delegations of this session whose child run is started and not yet reported. */
     async openDelegationChildren(sessionId) {

package/dist/native-worker/protocol.d.ts

@@ -145,6 +145,7 @@ export declare const WorkerInputSchema: z.ZodObject<{
     userTools: z.ZodRecord<z.ZodString, z.ZodObject<{
         code: z.ZodString;
         paramsZod: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     runsConcurrently: z.ZodArray<z.ZodString>;
     pricing: z.ZodObject<{

package/dist/native-worker/protocol.js

@@ -125,7 +125,10 @@ const LoadedToolSchema = z
     .object({ name: z.string(), description: z.string(), jsonSchema: z.record(z.string(), z.unknown()) })
     .strict();
 /** A user tool as the worker runs it: code and schema only. Capabilities stay on the gateway. */
-const WorkerUserToolSchema = z.object({ code: z.string(), paramsZod: z.string() }).strict();
+/** `timeoutMs`: the tool's time limit for this run, already capped by the server; absent = the default. */
+const WorkerUserToolSchema = z
+    .object({ code: z.string(), paramsZod: z.string(), timeoutMs: z.number().int().positive().optional() })
+    .strict();
 const PricingSchema = z
     .object({
     provider: z.string(),

package/dist/providers/coding-proxy/capability-hash.d.ts

@@ -0,0 +1,2 @@
+/** SHA-256 (base64url) of a run credential: the proxy stores only this, never the value. */
+export declare function capabilityHash(capability: string): string;

package/dist/providers/coding-proxy/capability-hash.js

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+/** SHA-256 (base64url) of a run credential: the proxy stores only this, never the value. */
+export function capabilityHash(capability) {
+    return createHash("sha256").update(capability).digest("base64url");
+}

package/dist/providers/coding-proxy/mcp-route.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The coding proxy's /mcp route (remote MCP servers, phase 2): the worker's MCP server URL. It
+ * checks the run's MCP token (`rmt_…`, WARDBY_MCP_TOKEN in the worker) against the proxy session,
+ * then forwards the JSON-RPC body unchanged, with the same Authorization, to the native gateway's
+ * /coding-mcp route (WARDBY_MCP_GATEWAY_URL), which checks the token again and runs the call. The
+ * proxy never sees an MCP server URL or secret; the gateway redacts results before they get here.
+ *
+ * Secrets: the token is only hashed and forwarded, never logged or echoed. The route's log line
+ * carries the session id, a sanitized JSON-RPC method, the status and a fixed reason code only:
+ * never the body, the token or an error's text. Every body this route writes is fixed text or the
+ * gateway's answer, unchanged.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ProxyLedger } from "./types.js";
+export declare const MCP_ROUTE_PATH = "/mcp";
+/** The longest a forwarded call may take, when the session's deadline is later. */
+export declare const MCP_FORWARD_MAX_MS: number;
+export declare const MCP_UNAVAILABLE_MESSAGE = "MCP tools aren't available on this server.";
+/**
+ * A JSON-RPC method as the log may carry it: its first 64 characters when they are letters, `/`
+ * and `_` only, else "other". Anything that starts like an MCP token is "other" too.
+ */
+export declare function mcpLogMethod(value: unknown): string;
+export interface McpRouteOptions {
+    ledger: Pick<ProxyLedger, "findSessionByMcpTokenHash">;
+    /** The native gateway's base URL; without one, /mcp answers 503 mcp_unavailable. */
+    gatewayUrl: string | undefined;
+    fetchImpl?: typeof fetch;
+    now?: () => Date;
+    log?: {
+        info(fields: Record<string, unknown>, message: string): void;
+    };
+}
+export declare function createMcpRoute(options: McpRouteOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/providers/coding-proxy/mcp-route.js

@@ -0,0 +1,166 @@
+import { isMcpToken, mcpTokenHash, MCP_TOKEN_REQUIRED_MESSAGE } from "../../coding/mcp-token.js";
+import { logger } from "../../core/logger.js";
+import { HTTP_LIMITS, HttpBoundaryError, readBodyBytes } from "../../mcp/transport/http-limits.js";
+export const MCP_ROUTE_PATH = "/mcp";
+/** The gateway's route this one forwards to. */
+const GATEWAY_PATH = "/coding-mcp";
+/** The longest a forwarded call may take, when the session's deadline is later. */
+export const MCP_FORWARD_MAX_MS = 5 * 60_000;
+/** The largest gateway answer relayed (a tool result is text the model reads; same as a model request). */
+const MAX_GATEWAY_RESPONSE_BYTES = 8 * 1024 * 1024;
+export const MCP_UNAVAILABLE_MESSAGE = "MCP tools aren't available on this server.";
+const MCP_UNREACHABLE_MESSAGE = "MCP tools can't be reached right now.";
+const LOG_METHOD = /^[A-Za-z/_]+$/;
+/**
+ * A JSON-RPC method as the log may carry it: its first 64 characters when they are letters, `/`
+ * and `_` only, else "other". Anything that starts like an MCP token is "other" too.
+ */
+export function mcpLogMethod(value) {
+    if (typeof value !== "string")
+        return "other";
+    const method = value.slice(0, 64);
+    return LOG_METHOD.test(method) && !method.includes("rmt_") ? method : "other";
+}
+function methodOf(body) {
+    try {
+        const message = JSON.parse(body.toString("utf8"));
+        return mcpLogMethod(message?.method);
+    }
+    catch {
+        return "other";
+    }
+}
+class GatewayError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+const JSON_HEADERS = { "content-type": "application/json", "cache-control": "no-store" };
+const rpcError = (code, message) => JSON.stringify({ jsonrpc: "2.0", id: null, error: { code, message } });
+async function readGatewayBody(response) {
+    const chunks = [];
+    let size = 0;
+    if (!response.body)
+        return Buffer.alloc(0);
+    for await (const chunk of response.body) {
+        size += chunk.byteLength;
+        if (size > MAX_GATEWAY_RESPONSE_BYTES) {
+            void response.body.cancel().catch(() => undefined);
+            throw new GatewayError("gateway_response_too_large");
+        }
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks, size);
+}
+export function createMcpRoute(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const now = options.now ?? (() => new Date());
+    const log = options.log ?? logger.child({ module: "coding-proxy" });
+    const gatewayUrl = options.gatewayUrl?.replace(/\/+$/, "");
+    return async (req, res) => {
+        const startedAt = performance.now();
+        const seen = {};
+        /** Refused before the body was read: close the connection rather than read what is still coming. */
+        const closeIfBodyUnread = () => {
+            if (!req.complete && !res.headersSent)
+                res.setHeader("connection", "close");
+        };
+        const send = (status, body, headers = JSON_HEADERS) => {
+            res.writeHead(status, headers).end(body);
+        };
+        try {
+            if (req.method !== "POST") {
+                closeIfBodyUnread();
+                res.setHeader("allow", "POST");
+                if (req.method === "HEAD")
+                    res.writeHead(405, JSON_HEADERS).end();
+                else
+                    send(405, rpcError(-32600, "Use POST."));
+                return;
+            }
+            if (!gatewayUrl) {
+                closeIfBodyUnread();
+                send(503, JSON.stringify({ error: "mcp_unavailable", message: MCP_UNAVAILABLE_MESSAGE }));
+                return;
+            }
+            const token = /^Bearer (\S+)$/.exec(req.headers.authorization ?? "")?.[1];
+            const session = isMcpToken(token)
+                ? await options.ledger.findSessionByMcpTokenHash(mcpTokenHash(token))
+                : undefined;
+            const at = now().getTime();
+            if (!session || session.status !== "active" || at >= session.deadlineAt.getTime()) {
+                // No WWW-Authenticate: a client must not start OAuth discovery against this route.
+                closeIfBodyUnread();
+                send(401, rpcError(-32001, MCP_TOKEN_REQUIRED_MESSAGE));
+                return;
+            }
+            seen.sessionId = session.id;
+            if (req.headers["content-type"]?.split(";", 1)[0].trim().toLowerCase() !== "application/json") {
+                closeIfBodyUnread();
+                send(415, rpcError(-32600, "Send one JSON-RPC message as application/json."));
+                return;
+            }
+            let body;
+            try {
+                body = await readBodyBytes(req, HTTP_LIMITS.json, AbortSignal.timeout(HTTP_LIMITS.requestMs));
+            }
+            catch (error) {
+                closeIfBodyUnread();
+                send(error instanceof HttpBoundaryError ? error.status : 400, rpcError(-32600, "The request body could not be read."));
+                return;
+            }
+            seen.method = methodOf(body);
+            // The call may take as long as it needs, up to the run's deadline or MCP_FORWARD_MAX_MS. The
+            // server's requestTimeout covers receiving the request only, which is over by now.
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(new GatewayError("gateway_timeout")), Math.min(MCP_FORWARD_MAX_MS, session.deadlineAt.getTime() - at));
+            const clientGone = () => {
+                if (!res.writableFinished)
+                    controller.abort(new GatewayError("client_disconnected"));
+            };
+            res.once("close", clientGone);
+            try {
+                const upstream = await fetchImpl(`${gatewayUrl}${GATEWAY_PATH}`, {
+                    method: "POST",
+                    headers: { authorization: req.headers.authorization, "content-type": "application/json" },
+                    body: new Uint8Array(body),
+                    redirect: "error",
+                    signal: controller.signal,
+                });
+                const answer = await readGatewayBody(upstream);
+                send(upstream.status, answer, {
+                    "content-type": upstream.headers.get("content-type") ?? "application/json",
+                    "cache-control": "no-store",
+                });
+            }
+            catch (error) {
+                const reason = controller.signal.reason instanceof GatewayError ? controller.signal.reason.reason : undefined;
+                throw error instanceof GatewayError ? error : new GatewayError(reason ?? "gateway_unreachable");
+            }
+            finally {
+                clearTimeout(timer);
+                res.off("close", clientGone);
+            }
+        }
+        catch (error) {
+            // Nothing of the error's text leaves or is logged: only a fixed reason code.
+            seen.reason = error instanceof GatewayError ? error.reason : "gateway_unreachable";
+            if (!res.headersSent)
+                send(502, JSON.stringify({ error: "mcp_unavailable", message: MCP_UNREACHABLE_MESSAGE }));
+            else
+                res.destroy();
+        }
+        finally {
+            log.info({
+                event: "mcp.request",
+                ...(seen.sessionId ? { sessionId: seen.sessionId } : {}),
+                ...(seen.method ? { method: seen.method } : {}),
+                status: res.statusCode,
+                ...(seen.reason ? { reason: seen.reason } : {}),
+                durationMs: Math.round(performance.now() - startedAt),
+            }, "coding proxy mcp request");
+        }
+    };
+}

package/dist/providers/coding-proxy/memory-ledger.d.ts

@@ -4,6 +4,7 @@ export declare class MemoryProxyLedger implements ProxyLedger {
     private readonly options;
     private readonly sessions;
     private readonly sessionByCapability;
+    private readonly sessionByMcpToken;
     private readonly requests;
     private readonly requestBySessionKey;
     private readonly startedAt;
@@ -11,6 +12,7 @@ export declare class MemoryProxyLedger implements ProxyLedger {
         now?: () => Date;
     });
     createSession(input: CreateProxySessionInput): Promise<void>;
+    findSessionByMcpTokenHash(mcpTokenHash: string): Promise<ProxySession | undefined>;
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
     complete(requestId: string, usage: ProxyUsage, actualCostUsd: number, upstreamStatus: number): Promise<ProxyRequest>;

package/dist/providers/coding-proxy/memory-ledger.js

@@ -10,6 +10,7 @@ function cloneSession(session) {
         terms: session.terms
             ? { version: session.terms.version, entry: { ...session.terms.entry, efforts: [...session.terms.entry.efforts] } }
             : null,
+        mcpTools: session.mcpTools ? structuredClone(session.mcpTools) : null,
     };
 }
 function cloneRequest(request) {
@@ -24,6 +25,7 @@ export class MemoryProxyLedger {
     options;
     sessions = new Map();
     sessionByCapability = new Map();
+    sessionByMcpToken = new Map();
     requests = new Map();
     requestBySessionKey = new Map();
     startedAt = new Map();
@@ -36,14 +38,28 @@ export class MemoryProxyLedger {
         }
         if (this.sessionByCapability.has(input.capabilityHash))
             throw new Error("proxy_capability_collision");
+        if (input.mcpTokenHash !== undefined && this.sessionByMcpToken.has(input.mcpTokenHash)) {
+            throw new Error("proxy_mcp_token_collision");
+        }
         const session = {
             ...input,
             allowedModels: [...input.allowedModels],
             status: "active",
             terms: input.terms ? normalizeProxyModelTerms(input.terms) : null,
+            mcpTools: input.mcpTools ? structuredClone(input.mcpTools) : null,
+            mcpTokenHash: input.mcpTokenHash ?? null,
+            mcpCallCount: 0,
+            runStepsLevel: input.runStepsLevel ?? null,
         };
         this.sessions.set(session.id, session);
         this.sessionByCapability.set(session.capabilityHash, session.id);
+        if (session.mcpTokenHash !== null)
+            this.sessionByMcpToken.set(session.mcpTokenHash, session.id);
+    }
+    async findSessionByMcpTokenHash(mcpTokenHash) {
+        const id = this.sessionByMcpToken.get(mcpTokenHash);
+        const session = id ? this.sessions.get(id) : undefined;
+        return session ? cloneSession(session) : undefined;
     }
     async findSessionByCapabilityHash(capabilityHash) {
         const id = this.sessionByCapability.get(capabilityHash);

package/dist/providers/coding-proxy/prisma-ledger.d.ts

@@ -20,6 +20,7 @@ export declare class PrismaProxyLedger implements ProxyLedger {
     private transaction;
     createSession(input: CreateProxySessionInput): Promise<void>;
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
+    findSessionByMcpTokenHash(mcpTokenHash: string): Promise<ProxySession | undefined>;
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
     complete(requestId: string, usage: ProxyUsage, actualCostUsd: number, upstreamStatus: number): Promise<ProxyRequest>;
     /**

package/dist/providers/coding-proxy/prisma-ledger.js

@@ -1,3 +1,4 @@
+import { RUN_STEPS_LEVELS } from "../../core/run-steps/config.js";
 import { logger } from "../../core/logger.js";
 import { normalizeProxyModelTerms } from "./types.js";
 const log = logger.child({ module: "coding-proxy-ledger" });
@@ -14,6 +15,9 @@ export const LEDGER_TRANSACTION_MAX_WAIT_MS = 5_000;
  *  the model request. The row lock it holds is per session, so a longer
  *  window only delays that run's own next request. */
 export const LEDGER_TRANSACTION_TIMEOUT_MS = 20_000;
+function isRunStepsLevel(value) {
+    return typeof value === "string" && RUN_STEPS_LEVELS.includes(value);
+}
 function sessionFromRow(row) {
     if (!Array.isArray(row.allowedModels) || !row.allowedModels.every((model) => typeof model === "string")) {
         throw new Error("invalid_proxy_session_models");
@@ -35,8 +39,27 @@ function sessionFromRow(row) {
         budgetExhaustedAt: row.budgetExhaustedAt ?? null,
         upstreamFailure: row.upstreamFailure ?? null,
         terms: sessionTerms(row),
+        mcpTools: sessionMcpTools(row),
+        mcpTokenHash: row.mcpTokenHash ?? null,
+        mcpCallCount: Number(row.mcpCallCount ?? 0),
+        runStepsLevel: isRunStepsLevel(row.runStepsLevel) ? row.runStepsLevel : null,
     };
 }
+/** The session's pinned MCP tools; null when it has none. Anything but a list of pins refuses the session. */
+function sessionMcpTools(row) {
+    const stored = row.mcpTools ?? null;
+    if (stored === null)
+        return null;
+    if (!Array.isArray(stored) ||
+        !stored.every((pin) => typeof pin === "object" &&
+            pin !== null &&
+            typeof pin.exposedName === "string" &&
+            typeof pin.toolName === "string" &&
+            typeof pin.serverId === "string")) {
+        throw new Error("invalid_proxy_session_mcp_tools");
+    }
+    return stored;
+}
 /**
  * The session's stored model terms. Null only when both columns are null (a session from before
  * the catalog, which prices from the shipped fallback); terms that are partly present or cannot be
@@ -109,22 +132,33 @@ export class PrismaProxyLedger {
         await this.db.$executeRaw `
       INSERT INTO "CodingProxySession"
         ("id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt",
-         "budgetUsd", "status", "registryTokenHash", "pricingVersion", "catalogEntry", "createdAt", "updatedAt")
+         "budgetUsd", "status", "registryTokenHash", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash", "runStepsLevel",
+         "createdAt", "updatedAt")
       VALUES
         (${input.id}, ${input.runId}, ${input.capabilityHash}, ${input.credentialRef}, ${input.protocol}, ${models}::jsonb,
          ${input.deadlineAt}, ${input.budgetUsd}, 'active', ${input.registryTokenHash},
          ${terms?.version ?? null}, ${terms ? JSON.stringify(terms.entry) : null}::jsonb,
+         ${input.mcpTools ? JSON.stringify(input.mcpTools) : null}::jsonb, ${input.mcpTokenHash ?? null},
+         ${input.runStepsLevel ?? null}::"RunStepsLevel",
          CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
     `;
     }
     async findSessionByCapabilityHash(capabilityHash) {
         const rows = await this.db.$queryRaw `
       SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status", "registryTokenHash",
-             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry"
+             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash", "mcpCallCount", "runStepsLevel"
       FROM "CodingProxySession" WHERE "capabilityHash" = ${capabilityHash}
     `;
         return rows[0] ? sessionFromRow(rows[0]) : null;
     }
+    async findSessionByMcpTokenHash(mcpTokenHash) {
+        const rows = await this.db.$queryRaw `
+      SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status", "registryTokenHash",
+             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash", "mcpCallCount", "runStepsLevel"
+      FROM "CodingProxySession" WHERE "mcpTokenHash" = ${mcpTokenHash}
+    `;
+        return rows[0] ? sessionFromRow(rows[0]) : undefined;
+    }
     async reserve(input) {
         return this.transaction(async (tx) => {
             const sessions = await tx.$queryRaw `

package/dist/providers/coding-proxy/proxy.d.ts

@@ -1,4 +1,9 @@
 import type { ModelPricing } from "../llm/pricing-core.js";
+import { capabilityHash } from "./capability-hash.js";
+import type { McpToolPin } from "../../core/mcp-tools.js";
+import { type StepCaptureOptions, type StreamStepExtractor } from "../../core/run-steps/extract.js";
+import { type RunStepsLevel } from "../../core/run-steps/config.js";
+import type { RunStepSubmitter } from "../../core/run-steps/types.js";
 import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyModelTerms, ProxyProtocol, ProxyRefusalRecord } from "./types.js";
 export declare const PROXY_MAX_BODY_BYTES: number;
 export declare const PROXY_MAX_OUTPUT_TOKENS = 1000000;
@@ -43,6 +48,12 @@ export interface CreateCodingProxySession {
     budgetUsd: number;
     /** The run's catalog entry recorded at dispatch; the session then prices and shapes requests from it. */
     terms?: ProxyModelTerms;
+    /** The run's pinned MCP tools (no URLs or secrets); only with mcpTokenHash, and only when there is one. */
+    mcpTools?: McpToolPin[];
+    /** SHA-256 (base64url) of the run's MCP token; the control plane mints and delivers the token itself. */
+    mcpTokenHash?: string;
+    /** The run's level (Run.runStepsLevel), fixed at dispatch; absent counts as summary. */
+    runStepsLevel?: RunStepsLevel;
 }
 export interface CreatedCodingProxySession {
     id: string;
@@ -69,8 +80,21 @@ export interface CodingProxyOptions {
      * dependency cache's seal, ModelRequestSeal). Awaited; a failure is ignored, never the request's.
      */
     onModelRequest?: (runId: string) => Promise<void>;
+    /**
+     * Where coding runs' steps go (RunStepForwarder, to the control plane's run-steps listener);
+     * absent, no step is extracted. Steps are read from frames after they are relayed and handed over
+     * unmasked (the control plane redacts them by exact value before writing). Extraction never fails,
+     * delays or alters a relay, and nothing of it is logged or written to the proxy's database.
+     * Tool-result output (its end) is sent only for a session at detail under a detail ceiling; at off
+     * nothing is read.
+     */
+    steps?: RunStepSubmitter;
+    /** The proxy's own WARDBY_RUN_STEPS: a session captures detail only when this is detail too. Default summary. */
+    runStepsCeiling?: RunStepsLevel;
+    /** Tests only: replaces the stream step extractor. */
+    createStepExtractor?: (protocol: ProxyProtocol, options?: StepCaptureOptions) => StreamStepExtractor;
 }
-export declare function capabilityHash(capability: string): string;
+export { capabilityHash };
 export declare class CodingProxy {
     private readonly ledger;
     private readonly credentials;
@@ -82,6 +106,11 @@ export declare class CodingProxy {
     private readonly priceVersion;
     private readonly activeRequests;
     private readonly onModelRequest?;
+    private readonly steps?;
+    private readonly createStepExtractor?;
+    private readonly runStepsCeiling;
+    /** Results already handed over, per session: each request resends the history. */
+    private readonly seenResults;
     constructor(options: CodingProxyOptions);
     createSession(input: CreateCodingProxySession): Promise<CreatedCodingProxySession>;
     cancelSession(sessionId: string): Promise<void>;
@@ -100,6 +129,9 @@ export declare class CodingProxy {
     private complete;
     private forwardJson;
     private forwardStream;
+    /** Queues a step batch for the control plane. Best effort: any failure drops the steps, never the request. */
+    private submitSteps;
+    private newStepExtractor;
     /** Best effort: the executor reads it to name the failure; it must never break the relay. */
     private recordUpstreamFailure;
     private markUncertain;