@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.41da3780c451

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

@@ -1,18 +1,34 @@
 import type { SessionService } from "../session/session.base.js";
-import { type DispatchSandboxResourceRequest, type RunOnceDispatchPacket } from "../session/session.types.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, BridgeLeaseUpdateRequest, BridgeReapRequest, 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 connections;
+    private readonly hostCapabilityProbe;
+    private readonly chatProcessRunner;
     private connection;
     private heartbeatTimer;
     private heartbeatInFlight;
@@ -22,40 +38,81 @@ export declare class ForgeBridgeService implements BridgeService {
     private sandboxMaintenanceTimer;
     private sandboxMaintenanceRunning;
     private closed;
+    private transportRecovery;
+    private transportRecoveryGeneration;
     private stopped;
     private readonly activeSessions;
     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;
-    constructor(config: BridgeServiceConfig, sessions?: SessionService | undefined, connections?: BridgeConnectionFactory, preflight?: DockerPreflight, sandboxRuntime?: SandboxRuntime, sandboxResourceResolver?: SandboxResourceResolver);
+    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;
@@ -63,11 +120,16 @@ export declare class ForgeBridgeService implements BridgeService {
     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;
 }
@@ -81,7 +143,10 @@ 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;
@@ -92,12 +157,16 @@ export declare class SignalRBridgeConnection implements BridgeConnection {
 }
 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>;