@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.04a1e5b9e484

package/dist/bridge/bridge-chat.types.js

@@ -0,0 +1,401 @@
+export const bridgeChatProtocolVersion = "chat_interactive_v1";
+export const bridgeChatUpdateRequiredCode = "update_required";
+export const bridgeChatMaxCallbackPayloadBytes = 256 * 1024;
+export const bridgeChatMaxProviderThreadIdChars = 256;
+const supportedAvailability = new Set(["available", "degraded", "unavailable"]);
+const supportedRequestedCapabilities = new Set([
+    "text",
+    "cancel",
+    "resume",
+    "thread_continuity",
+    "attachment_handoffs",
+    "action_broker_grants",
+]);
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const unixEpochMs = Date.parse("1970-01-01T00:00:00.000Z");
+const maxOpaqueHandleChars = 4096;
+const maxGrantNonceChars = 4096;
+const maxMetadataStringChars = 4096;
+export function unavailableBridgeChatCapability(protocolVersion = bridgeChatProtocolVersion, unavailableCode, unavailableReason) {
+    return {
+        availability: "unavailable",
+        protocolVersion: nonEmptyStringOr(protocolVersion, bridgeChatProtocolVersion),
+        supportedProviders: [],
+        supportedModels: [],
+        supportsTextStreaming: false,
+        supportsCancel: false,
+        supportsResume: false,
+        supportsProviderThreadContinuity: false,
+        supportsAttachments: false,
+        supportsActionBrokerGrants: false,
+        maxMessageBytes: 0,
+        maxContextRefs: 0,
+        unavailableCode: cleanOptionalString(unavailableCode),
+        unavailableReason: cleanOptionalString(unavailableReason),
+    };
+}
+export function normalizeBridgeChatCapability(value) {
+    if (!value) {
+        return unavailableBridgeChatCapability();
+    }
+    const protocolVersion = nonEmptyStringOr(value.protocolVersion, bridgeChatProtocolVersion);
+    if (protocolVersion !== bridgeChatProtocolVersion) {
+        return unavailableBridgeChatCapability(protocolVersion, bridgeChatUpdateRequiredCode, `Bridge Chat protocol '${protocolVersion}' is not supported by this bridge.`);
+    }
+    const availability = supportedAvailability.has(value.availability) ? value.availability : "unavailable";
+    return {
+        availability,
+        protocolVersion: bridgeChatProtocolVersion,
+        supportedProviders: cleanStringArray(value.supportedProviders, true),
+        supportedModels: cleanStringArray(value.supportedModels, false),
+        supportsTextStreaming: value.supportsTextStreaming === true,
+        supportsCancel: value.supportsCancel === true,
+        supportsResume: value.supportsResume === true,
+        supportsProviderThreadContinuity: value.supportsProviderThreadContinuity === true,
+        supportsAttachments: value.supportsAttachments === true,
+        supportsActionBrokerGrants: value.supportsActionBrokerGrants === true,
+        maxMessageBytes: nonNegativeInteger(value.maxMessageBytes),
+        maxContextRefs: nonNegativeInteger(value.maxContextRefs),
+        unavailableCode: availability === "unavailable" ? cleanOptionalString(value.unavailableCode) : null,
+        unavailableReason: availability === "unavailable" ? cleanOptionalString(value.unavailableReason) : null,
+    };
+}
+export function parseChatTurnDispatchPacket(value, capability = unavailableBridgeChatCapability()) {
+    const packet = asObject(value, "chat turn dispatch packet");
+    const protocolVersion = requiredString(packet, "protocolVersion");
+    if (protocolVersion !== bridgeChatProtocolVersion) {
+        throw new Error(`Unsupported chat protocolVersion: ${protocolVersion}`);
+    }
+    assertReservedFieldsAbsent(packet, "chat turn dispatch packet");
+    const normalizedCapability = normalizeBridgeChatCapability(capability);
+    const messages = parseMessages(packet.messages, normalizedCapability.maxMessageBytes);
+    const contextRefs = parseContextRefs(packet.contextRefs);
+    if (normalizedCapability.maxContextRefs > 0 && contextRefs.length > normalizedCapability.maxContextRefs) {
+        throw new Error("contextRefs exceeds maxContextRefs.");
+    }
+    const turnId = requiredUuid(packet, "turnId");
+    const leaseId = requiredUuid(packet, "leaseId");
+    const fencingToken = requiredUuid(packet, "fencingToken");
+    const requestedCapabilities = parseRequestedCapabilities(packet.requestedCapabilities, normalizedCapability);
+    const attachmentHandoffs = parseAttachmentHandoffs(packet.attachmentHandoffs, normalizedCapability, requestedCapabilities);
+    const actionBrokerGrants = parseActionBrokerGrants(packet.actionBrokerGrants, normalizedCapability, requestedCapabilities);
+    assertBoundedEnvelopesMatchFence(attachmentHandoffs, actionBrokerGrants, turnId, leaseId, fencingToken);
+    return {
+        chatRunId: requiredUuid(packet, "chatRunId"),
+        conversationId: requiredUuid(packet, "conversationId"),
+        turnId,
+        leaseId,
+        fencingToken,
+        runnerInstanceId: requiredUuid(packet, "runnerInstanceId"),
+        providerKind: requiredString(packet, "providerKind").trim().toLowerCase(),
+        model: requiredString(packet, "model").trim(),
+        messages,
+        contextRefs,
+        idempotencyKey: requiredString(packet, "idempotencyKey").trim(),
+        providerThreadId: optionalString(packet, "providerThreadId", bridgeChatMaxProviderThreadIdChars),
+        protocolVersion: bridgeChatProtocolVersion,
+        requestedCapabilities,
+        attachmentHandoffs,
+        actionBrokerGrants,
+    };
+}
+export function isTerminalChatTurnCallbackKind(kind) {
+    return kind === "output_completed" || kind === "failed" || kind === "cancelled" || kind === "expired";
+}
+export function assertBridgeChatCallbackPayload(value, label = "payload") {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object when provided.`);
+    }
+    if (new TextEncoder().encode(JSON.stringify(value)).byteLength > bridgeChatMaxCallbackPayloadBytes) {
+        throw new Error(`${label} exceeds maxCallbackPayloadBytes.`);
+    }
+}
+function parseMessages(value, maxMessageBytes) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("messages must be a non-empty array.");
+    }
+    return value.map((entry, index) => {
+        const message = asObject(entry, `messages[${index}]`);
+        assertReservedFieldsAbsent(message, `messages[${index}]`);
+        const content = requiredString(message, "content");
+        if (maxMessageBytes > 0 && new TextEncoder().encode(content).byteLength > maxMessageBytes) {
+            throw new Error(`messages[${index}].content exceeds maxMessageBytes.`);
+        }
+        return {
+            role: requiredString(message, "role").trim(),
+            content,
+            metadata: optionalObject(message.metadata, `messages[${index}].metadata`),
+        };
+    });
+}
+function parseContextRefs(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("contextRefs must be an array when provided.");
+    }
+    return value.map((entry, index) => {
+        const ref = asObject(entry, `contextRefs[${index}]`);
+        assertReservedFieldsAbsent(ref, `contextRefs[${index}]`);
+        return {
+            kind: requiredString(ref, "kind").trim(),
+            refId: requiredString(ref, "refId").trim(),
+            title: optionalString(ref, "title"),
+            summary: optionalString(ref, "summary"),
+            metadata: optionalObject(ref.metadata, `contextRefs[${index}].metadata`),
+        };
+    });
+}
+function parseAttachmentHandoffs(value, capability, requestedCapabilities) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("attachmentHandoffs must be an array when provided.");
+    }
+    if (value.length > 0 && !capability.supportsAttachments) {
+        throw new Error("Bridge Chat attachmentHandoffs require supportsAttachments.");
+    }
+    if (value.length > 0 && !requestedCapabilities.includes("attachment_handoffs")) {
+        throw new Error("Bridge Chat attachmentHandoffs require requestedCapabilities to include attachment_handoffs.");
+    }
+    return value.map((entry, index) => {
+        const handoff = asObject(entry, `attachmentHandoffs[${index}]`);
+        assertOnlyKeys(handoff, `attachmentHandoffs[${index}]`, [
+            "turnId",
+            "attachmentId",
+            "tempFileToken",
+            "mimeType",
+            "sizeBytes",
+            "sha256",
+            "fileNameDisplay",
+            "expiresAt",
+            "status",
+        ]);
+        const status = requiredString(handoff, "status").trim();
+        if (status !== "available") {
+            throw new Error(`attachmentHandoffs[${index}].status must be available.`);
+        }
+        return {
+            turnId: requiredUuid(handoff, "turnId"),
+            attachmentId: requiredUuid(handoff, "attachmentId"),
+            tempFileToken: boundedRequiredString(handoff, "tempFileToken", maxOpaqueHandleChars),
+            mimeType: boundedRequiredString(handoff, "mimeType", maxMetadataStringChars),
+            sizeBytes: requiredNonNegativeInteger(handoff, "sizeBytes"),
+            sha256: boundedRequiredString(handoff, "sha256", maxMetadataStringChars),
+            fileNameDisplay: boundedRequiredString(handoff, "fileNameDisplay", maxMetadataStringChars),
+            expiresAt: requiredFutureContractTimestamp(handoff, "expiresAt"),
+            status,
+        };
+    });
+}
+function parseActionBrokerGrants(value, capability, requestedCapabilities) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("actionBrokerGrants must be an array when provided.");
+    }
+    if (value.length > 0 && !capability.supportsActionBrokerGrants) {
+        throw new Error("Bridge Chat actionBrokerGrants require supportsActionBrokerGrants.");
+    }
+    if (value.length > 0 && !requestedCapabilities.includes("action_broker_grants")) {
+        throw new Error("Bridge Chat actionBrokerGrants require requestedCapabilities to include action_broker_grants.");
+    }
+    return value.map((entry, index) => {
+        const grant = asObject(entry, `actionBrokerGrants[${index}]`);
+        assertOnlyKeys(grant, `actionBrokerGrants[${index}]`, [
+            "grantId",
+            "turnId",
+            "leaseId",
+            "fencingToken",
+            "allowedScopes",
+            "nonce",
+            "expiresAt",
+            "redactionStatus",
+        ]);
+        const redactionStatus = requiredString(grant, "redactionStatus").trim();
+        if (redactionStatus !== "redacted" && redactionStatus !== "not_applicable") {
+            throw new Error(`actionBrokerGrants[${index}].redactionStatus is unsupported.`);
+        }
+        return {
+            grantId: requiredUuid(grant, "grantId"),
+            turnId: requiredUuid(grant, "turnId"),
+            leaseId: requiredUuid(grant, "leaseId"),
+            fencingToken: requiredUuid(grant, "fencingToken"),
+            allowedScopes: requiredSortedStringArray(grant, "allowedScopes"),
+            nonce: boundedRequiredString(grant, "nonce", maxGrantNonceChars),
+            expiresAt: requiredFutureContractTimestamp(grant, "expiresAt"),
+            redactionStatus,
+        };
+    });
+}
+function parseRequestedCapabilities(value, capability) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("requestedCapabilities must be an array when provided.");
+    }
+    return value.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`requestedCapabilities[${index}] must be a non-empty string.`);
+        }
+        const requestedCapability = entry.trim().toLowerCase();
+        if (!supportedRequestedCapabilities.has(requestedCapability)) {
+            throw new Error(`Bridge Chat v1 does not support requestedCapabilities ${requestedCapability}.`);
+        }
+        if (requestedCapability === "attachment_handoffs" && !capability.supportsAttachments) {
+            throw new Error("Bridge Chat v1 does not support requestedCapabilities attachment_handoffs for this runner.");
+        }
+        if (requestedCapability === "action_broker_grants" && !capability.supportsActionBrokerGrants) {
+            throw new Error("Bridge Chat v1 does not support requestedCapabilities action_broker_grants for this runner.");
+        }
+        return requestedCapability;
+    });
+}
+function assertBoundedEnvelopesMatchFence(attachmentHandoffs, actionBrokerGrants, turnId, leaseId, fencingToken) {
+    attachmentHandoffs.forEach((handoff, index) => {
+        if (handoff.turnId !== turnId) {
+            throw new Error(`attachmentHandoffs[${index}].turnId must match turnId.`);
+        }
+    });
+    actionBrokerGrants.forEach((grant, index) => {
+        if (grant.turnId !== turnId || grant.leaseId !== leaseId || grant.fencingToken !== fencingToken) {
+            throw new Error(`actionBrokerGrants[${index}] must match the active dispatch fence.`);
+        }
+    });
+}
+function assertReservedFieldsAbsent(source, label) {
+    for (const key of ["attachments", "attachmentHandles", "actionGrants"]) {
+        if (source[key] !== undefined && source[key] !== null) {
+            throw new Error(`${label}.${key} is reserved for a later Bridge Chat protocol.`);
+        }
+    }
+}
+function assertOnlyKeys(source, label, allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(source)) {
+        if (!allowed.has(key)) {
+            throw new Error(`${label}.${key} is not supported by Bridge Chat v1.`);
+        }
+    }
+}
+function asObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function optionalObject(value, label) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return asObject(value, label);
+}
+function requiredUuid(source, key) {
+    const value = requiredString(source, key).trim();
+    if (!uuidPattern.test(value)) {
+        throw new Error(`${key} must be a UUID.`);
+    }
+    return value;
+}
+function requiredString(source, key) {
+    const value = source[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${key} must be a non-empty string.`);
+    }
+    return value;
+}
+function boundedRequiredString(source, key, maxLength) {
+    const clean = requiredString(source, key).trim();
+    if (clean.length > maxLength) {
+        throw new Error(`${key} exceeds ${maxLength} characters.`);
+    }
+    return clean;
+}
+function requiredNonNegativeInteger(source, key) {
+    const value = source[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${key} must be a non-negative integer.`);
+    }
+    return value;
+}
+function requiredSortedStringArray(source, key) {
+    const value = source[key];
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`${key} must be a non-empty string array.`);
+    }
+    const cleaned = value.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`${key}[${index}] must be a non-empty string.`);
+        }
+        return entry.trim();
+    });
+    if (new Set(cleaned).size !== cleaned.length) {
+        throw new Error(`${key} must not contain duplicate values.`);
+    }
+    const sorted = [...cleaned].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+    if (cleaned.some((scope, index) => scope !== sorted[index])) {
+        throw new Error(`${key} must be sorted.`);
+    }
+    return cleaned;
+}
+function requiredFutureContractTimestamp(source, key) {
+    const value = requiredString(source, key).trim();
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed) || parsed <= unixEpochMs) {
+        throw new Error(`${key} is required.`);
+    }
+    return value;
+}
+function optionalString(source, key, maxLength) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${key} must be a string when provided.`);
+    }
+    const clean = value.trim();
+    if (clean.length === 0) {
+        return null;
+    }
+    if (maxLength !== undefined && clean.length > maxLength) {
+        throw new Error(`${key} exceeds maxProviderThreadIdChars.`);
+    }
+    return clean;
+}
+function cleanOptionalString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const clean = value.trim();
+    return clean.length === 0 ? null : clean;
+}
+function nonEmptyStringOr(value, fallback) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+function cleanStringArray(values, lower) {
+    const seen = new Set();
+    const cleaned = [];
+    for (const value of values) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            continue;
+        }
+        const clean = lower ? value.trim().toLowerCase() : value.trim();
+        const key = clean.toLowerCase();
+        if (!seen.has(key)) {
+            seen.add(key);
+            cleaned.push(clean);
+        }
+    }
+    return cleaned;
+}
+function nonNegativeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}

package/dist/bridge/bridge.base.d.ts

@@ -1,4 +1,4 @@
-import type { BridgeCancelHandler, BridgeDispatchHandler, BridgeServiceConfig } from "./bridge.types.js";
+import type { BridgeCancelHandler, BridgeChatTurnHandler, BridgeDispatchHandler, BridgeLeaseUpdateHandler, BridgeOfferHandler, BridgeReadinessProbeHandler, BridgeReapHandler, BridgeServiceConfig, BridgeStartHandler } from "./bridge.types.js";
 export interface BridgeService {
     connectOnce(): Promise<void>;
     run(signal?: AbortSignal): Promise<void>;
@@ -8,8 +8,16 @@ export interface BridgeConnection {
     start(): Promise<void>;
     stop(): Promise<void>;
     onClose(handler: (error?: Error) => void): void;
+    onReconnecting?(handler: (error?: Error) => void): void;
+    onReconnected?(handler: (connectionId?: string) => void | Promise<void>): void;
     onDispatch(handler: BridgeDispatchHandler): void;
+    onChatTurn?(handler: BridgeChatTurnHandler): void;
+    onOffer?(handler: BridgeOfferHandler): void;
+    onStart?(handler: BridgeStartHandler): void;
+    onLeaseUpdate?(handler: BridgeLeaseUpdateHandler): void;
     onCancel(handler: BridgeCancelHandler): void;
+    onReap?(handler: BridgeReapHandler): void;
+    onReadinessProbe?(handler: BridgeReadinessProbeHandler): void;
     invoke<TResponse>(methodName: string, payload: unknown): Promise<TResponse>;
 }
 export interface BridgeConnectionFactory {

package/dist/bridge/bridge.service.d.ts

@@ -1,30 +1,135 @@
 import type { SessionService } from "../session/session.base.js";
+import type { ProviderProcessRunner } from "../session/provider-cli/provider-cli.process.js";
+import { DockerEngineProbe, type DockerEngineCapabilitySnapshot } from "../runtime/docker-engine-probe.js";
+import { type DispatchSandboxResourceRequest, type RunOnceDispatchPacket, type RunOnceResultPacket } from "../session/session.types.js";
+import { DockerPreflight } from "../sandbox/preflight.js";
+import type { SandboxPreflightResult } from "../sandbox/sandbox.types.js";
+import { type SandboxRuntime } from "../sandbox/runtime.js";
 import type { BridgeConnection, BridgeConnectionFactory, BridgeService } from "./bridge.base.js";
-import type { BridgeCancelHandler, BridgeDispatchHandler, BridgeServiceConfig } from "./bridge.types.js";
+import { type RunnerHostCapabilityProbe } from "./runner-host-capabilities.js";
+import type { BridgeCancelHandler, BridgeChatTurnHandler, BridgeDispatchHandler, BridgeLeaseUpdateRequest, BridgeReapRequest, BridgeServiceConfig } from "./bridge.types.js";
+import { type ReadinessResultOutbox } from "./readiness-result-outbox.js";
+import { type DispatchResultOutbox } from "./dispatch-result-outbox.js";
+export type SandboxResourceResolver = (dispatch: RunOnceDispatchPacket) => Promise<ResolvedSandboxResourceProfile>;
+export interface ResolvedSandboxResourceProfile {
+    readonly resources: DispatchSandboxResourceRequest;
+    readonly sandboxConfigCommitSha: string;
+}
+/**
+ * Protocol-v2 events are acknowledged one at a time before runOnce returns.
+ * Sending the complete transcript again in DispatchResult made long QA and CI
+ * sessions exceed SignalR's receive limit, disconnecting the bridge after the
+ * provider had already completed. The API combines its acknowledged streamed
+ * events with the terminal result, so the callback only needs the outcome and
+ * artifacts. Protocol v1 retains the transcript for legacy servers.
+ */
+export declare function compactTerminalResult(dispatch: RunOnceDispatchPacket, result: RunOnceResultPacket): RunOnceResultPacket;
 export declare class ForgeBridgeService implements BridgeService {
     private readonly config;
-    private readonly sessions;
     private readonly connections;
+    private readonly hostCapabilityProbe;
+    private readonly chatProcessRunner;
     private connection;
     private heartbeatTimer;
+    private heartbeatInFlight;
+    private consecutiveHeartbeatFailures;
+    private reconnectingFromHeartbeatFailure;
+    private leaseWatchdogTimer;
+    private sandboxMaintenanceTimer;
+    private sandboxMaintenanceRunning;
     private closed;
+    private transportRecovery;
+    private transportRecoveryGeneration;
     private stopped;
     private readonly activeSessions;
-    constructor(config: BridgeServiceConfig, sessions?: SessionService, connections?: BridgeConnectionFactory);
+    private readonly reservations;
+    private readonly activeReadinessProbes;
+    private readonly readinessResultOutbox;
+    private readinessResultFlush;
+    private readonly dispatchResultOutbox;
+    private dispatchResultFlush;
+    private dispatchResultGeneration;
+    private dispatchResultFlushedGeneration;
+    private readonly dispatchResultHandoffs;
+    private readonly preflight;
+    private readonly dockerEngineProbe;
+    private readonly sandboxRuntime;
+    private readonly sandboxResourceResolver;
+    private readonly sessions;
+    private readonly enforceHostDatabaseCapabilityBoundary;
+    private hostCapabilities;
+    private readonly recoveredHostAttempts;
+    private hostCapabilitiesDetected;
+    constructor(config: BridgeServiceConfig, sessions?: SessionService | undefined, connections?: BridgeConnectionFactory, preflight?: DockerPreflight, sandboxRuntime?: SandboxRuntime, sandboxResourceResolver?: SandboxResourceResolver, dockerEngineProbe?: DockerEngineProbe, hostCapabilityProbe?: RunnerHostCapabilityProbe, readinessResultOutbox?: ReadinessResultOutbox, chatProcessRunner?: ProviderProcessRunner, dispatchResultOutbox?: DispatchResultOutbox);
     connectOnce(): Promise<void>;
+    private rememberRecoveredHostAttempts;
+    private recoveredHostAttemptsForHello;
+    private registerConnection;
     run(signal?: AbortSignal): Promise<void>;
     stop(): Promise<void>;
+    private handleChatTurn;
+    private createChatTurnWorkspace;
+    private runChatProviderProcess;
+    private sendChatProviderEvent;
+    private sendChatAbortTerminal;
+    private sendStandaloneChatTerminal;
+    private sendChatCallback;
+    private invokeChatCallbackWithRetry;
+    private requiredChatCapabilityFailure;
+    private bridgeChatCapability;
     private handleDispatch;
+    private reservedDispatchHandoffIsCurrent;
+    private releaseReservedDispatchHandoff;
+    private releaseActiveSessionAndRefreshCapacity;
+    private handleOffer;
+    private commitOfferReservation;
+    private handleStart;
+    private redeemSecretGrant;
+    private redeemPublishGrant;
+    private handleLeaseUpdate;
+    private sendOfferDecision;
     private parseDispatchOrReport;
+    private parseChatTurnOrReport;
     private handleCancel;
+    private chatCancelMatchesActiveTurn;
+    private handleReap;
+    private handleReadinessProbe;
+    private deferActiveReadinessProbes;
+    private flushReadinessResults;
+    private flushReadinessResultsCore;
     private abortActiveSessions;
+    private abortActiveReadinessProbes;
+    private normalizeReadinessProbe;
     private normalizeDispatch;
     private sendResult;
+    private sendLegacyResult;
+    private sendResultPayload;
+    private sendResultPayloadDirect;
+    private flushDispatchResults;
+    private flushDispatchResultsCore;
     private startHeartbeat;
+    private heartbeatTick;
+    private startLeaseWatchdog;
+    private stopLeaseWatchdog;
+    private expireLeases;
+    private expireReservations;
     private stopHeartbeat;
+    private startSandboxMaintenance;
+    private stopSandboxMaintenance;
+    private runSandboxMaintenance;
+    private readAttemptSnapshot;
+    private flushCleanupReports;
     private sendHeartbeat;
+    private sendHeartbeatSnapshot;
     private capabilities;
+    private requiredCapabilityFailure;
+    private usedSandboxResources;
+    private activeSandboxResources;
+    private sandboxResourceCapacity;
     private invokeAck;
+    private beginTransportRecovery;
+    private completeTransportRecovery;
+    private waitForTransportRecovery;
     private waitForClose;
     private stopConnection;
 }
@@ -38,9 +143,30 @@ export declare class SignalRBridgeConnection implements BridgeConnection {
     start(): Promise<void>;
     stop(): Promise<void>;
     onClose(handler: (error?: Error) => void): void;
+    onReconnecting(handler: (error?: Error) => void): void;
+    onReconnected(handler: (connectionId?: string) => void | Promise<void>): void;
     onDispatch(handler: BridgeDispatchHandler): void;
+    onChatTurn(handler: BridgeChatTurnHandler): void;
+    onOffer(handler: BridgeDispatchHandler): void;
+    onStart(handler: BridgeDispatchHandler): void;
+    onLeaseUpdate(handler: (request: BridgeLeaseUpdateRequest) => Promise<void>): void;
     onCancel(handler: BridgeCancelHandler): void;
+    onReap(handler: (request: BridgeReapRequest) => Promise<void>): void;
+    onReadinessProbe(handler: (request: unknown) => Promise<void>): void;
     invoke<TResponse>(methodName: string, payload: unknown): Promise<TResponse>;
 }
 export declare function defaultBridgeServiceConfig(overrides?: Partial<BridgeServiceConfig>): BridgeServiceConfig;
 export declare function resolveBridgeRunnerHubUrl(serverUrl: string): URL;
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function waitForPromiseOrAbort(promise: Promise<unknown>, signal?: AbortSignal): Promise<void>;
+export declare function canReapManagedSandboxes(preflight: {
+    readonly healthy: boolean;
+    readonly unavailableCode?: string | null;
+}): boolean;
+export declare function dockerEngineRequirementFailure(requiredCapabilities: readonly string[], executionMode: string | undefined, capability: DockerEngineCapabilitySnapshot | null): string | null;
+export type SandboxResourceVector = DispatchSandboxResourceRequest;
+export declare function canReserveSandboxResources(used: SandboxResourceVector, requested: SandboxResourceVector, capacity: SandboxResourceVector): boolean;
+export declare function sandboxMemoryCommitmentCapacity(preflight: Pick<SandboxPreflightResult, "totalMemoryBytes" | "availableMemoryBytes" | "hostReserveBytes">, activeMemoryBytes: number): number;
+export declare function sandboxCapacityFailureMessage(used: SandboxResourceVector, requested: SandboxResourceVector, capacity: SandboxResourceVector, preflight: SandboxPreflightResult | null, config: BridgeServiceConfig): string;
+export declare function resolveDynamicSandboxResources(requested: DispatchSandboxResourceRequest, serviceCount: number, networkMode: "offline" | "public_allowlist" | "open_public", baseRuntimeOverheadBytes?: number): DispatchSandboxResourceRequest;
+export declare function resolveSandboxResourcesFromRepo(dispatch: RunOnceDispatchPacket, baseRuntimeOverheadBytes?: number): Promise<ResolvedSandboxResourceProfile>;