codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.4

package/dist/src/backend/client.d.ts

@@ -5,13 +5,20 @@ import type { CommandDescriptor } from "../commands/registry.js";
 import type { ChatGPTResponsesCreateArgs } from "../runner/responses.js";
 import type { ChatGPTRunStream } from "../runner/stream.js";
 import type { ChatGPTAgent, ChatGPTAgentConfig, ChatGPTResponse, ChatGPTRunInput, ChatGPTRunResult } from "../runner/types.js";
+import type { OperationCollectRequestV1, OperationControlRequestV1, OperationInspectRequestV1, OperationSubmitRequestV1 } from "../operations/types.js";
+import { type OperationCollectWireResult, type OperationControlWireResult, type OperationInspectWireResult, type OperationSubmitWireResult } from "../operations/wire-results.js";
 import type { ReportRedactionOptions } from "../safety/report-redaction.js";
 import type { ArtifactDownloadArgs, ArtifactWaitArgs, ApplyConfigurationData, ApplyConfigurationArgs, BootstrapArgs, ChatGPTExperience, CommandResult, ConfigurationInspectionData, CopyResponseArgs, DetectExperienceArgs, DetectExperienceData, DownloadLatestArgs, GetModeArgs, GetModeData, InspectConfigurationArgs, ListArtifactsArgs, MessageStatusArgs, StopGenerationArgs, StopGenerationData, NewThreadArgs, OpenThreadArgs, OpenExperienceData, ReadLatestArgs, ReadWorkLatestArgs, ReadWorkLatestData, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, WaitArgs, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "../types.js";
-import { type BackendEvent, type BackendRequest, type BackendResponse } from "./protocol.js";
+import { type BackendCompatibilityReport, type BackendEvent, type BackendRequest, type BackendResponse } from "./protocol.js";
+import type { BackendCompatibilityExpectedIdentity } from "./compatibility.js";
 export type BackendTransport = {
     request(request: BackendRequest): Promise<BackendResponse>;
     stream(request: BackendRequest): AsyncIterable<BackendEvent>;
+    /** Cancel locally pending delivery without claiming that the backend stopped. */
+    cancel?: (requestId: string, reason?: Error) => boolean;
     close?: () => Promise<void> | void;
+    /** Last bounded compatibility result for the current backend generation. */
+    getCompatibilityReport?: () => BackendCompatibilityReport | undefined;
 };
 export declare class BackendClientError extends Error {
     readonly code: string;
@@ -23,10 +30,24 @@ export type ChatGPTBackendRunner = {
     plan<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): Promise<SequencePlan>;
     stream<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): ChatGPTRunStream<TOutput>;
 };
+/**
+ * The backend operations facade deliberately uses the versioned wire request
+ * envelopes as its direct payloads.  There is no `{ request: ... }` wrapper:
+ * this keeps the Node, Python, and backend transports on one canonical shape
+ * and makes accidental extra fields observable at the boundary.
+ */
+export type ChatGPTBackendOperations = {
+    submit(request: OperationSubmitRequestV1): Promise<OperationSubmitWireResult>;
+    collect(request: OperationCollectRequestV1): Promise<OperationCollectWireResult>;
+    inspect(request: OperationInspectRequestV1): Promise<OperationInspectWireResult>;
+    control(request: OperationControlRequestV1): Promise<OperationControlWireResult>;
+};
 export type ChatGPTBackendClient = {
     agent<TOutput = string>(config: ChatGPTAgentConfig<TOutput>): ChatGPTAgent<TOutput>;
     run<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): Promise<ChatGPTRunResult<TOutput>>;
     runner: ChatGPTBackendRunner;
+    compatibility(): BackendCompatibilityReport | undefined;
+    operations: ChatGPTBackendOperations;
     responses: {
         create(args: ChatGPTResponsesCreateArgs | Record<string, unknown>): Promise<ChatGPTResponse>;
     };
@@ -136,6 +157,19 @@ export type StdioBackendTransportOptions = {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;
+    handshakeTimeoutMs?: number;
+    /** Aggregate bound for caller routes plus transport control routes. */
+    maxInFlight?: number;
+    streamQueueLimit?: number;
+    streamQueueBytesLimit?: number;
+    writeQueueLimit?: number;
+    writeQueueBytesLimit?: number;
+    lateOutputGraceMs?: number;
+    tombstoneLimit?: number;
+    quarantineLimit?: number;
+    frameLimitBytes?: number;
+    /** Optional caller provenance used only for bounded compatibility diagnostics. */
+    expectedIdentity?: BackendCompatibilityExpectedIdentity;
 };
 export declare class StdioBackendTransport implements BackendTransport {
     private readonly options;
@@ -143,13 +177,53 @@ export declare class StdioBackendTransport implements BackendTransport {
     private stdout;
     private pendingResponses;
     private pendingStreams;
-    private stderrText;
+    private waitingRequests;
+    private waitingStreams;
+    private waitingAdmissionIds;
+    private activeRequestIds;
+    private activeControlRequestIds;
+    private activeWrites;
+    private writeQueueCount;
+    private writeQueueBytes;
+    private tombstones;
+    private quarantinedRequestIds;
+    private writeTail;
+    private retiredWriteTail;
+    private recycleBlockedByWriteTeardown;
+    private legacyTail;
+    private handshakeState;
+    private handshakePromise;
+    private handshakeGeneration;
+    private readonly requestIdPrefix;
+    private handshakeError;
+    private compatibilityReport;
+    private protocolQuarantined;
+    private quarantineRecycleTimer;
+    private tombstoneRecycleTimer;
+    private stderrBytes;
+    private stderrTruncated;
+    private closed;
     constructor(options: StdioBackendTransportOptions);
     request(request: BackendRequest): Promise<BackendResponse>;
     stream(request: BackendRequest): AsyncIterable<BackendEvent>;
+    cancel(requestId: string, reason?: Error): boolean;
     close(): Promise<void>;
     private start;
+    private readStdout;
+    private ensureHandshake;
+    private negotiateLegacyBackend;
+    getCompatibilityReport(): BackendCompatibilityReport | undefined;
+    private issueResponse;
+    private issueStream;
     private write;
+    private admitWrite;
+    private releaseWrite;
+    private retireWriteLifecycle;
+    private finishRetiredWriteTail;
+    private maybeUnblockWriteTeardown;
+    private isWriteRouteActive;
+    private hasStartedWrite;
+    private writeLine;
     private handleLine;
     private handleResponse;
     private handleEvent;
@@ -157,4 +231,31 @@ export declare class StdioBackendTransport implements BackendTransport {
     private clearResponse;
     private clearStream;
     private createDeadline;
+    private acquireLegacySlot;
+    private reserveWaitingAdmission;
+    private releaseWaitingAdmission;
+    private promoteWaitingAdmission;
+    private reserveRequestId;
+    private validateRequestId;
+    private assertAdmissionCapacity;
+    private releaseRequestId;
+    private discardLateOrQuarantine;
+    private consumeTombstoneResponse;
+    private consumeTombstoneEvent;
+    private lateOutputGraceMs;
+    private tombstoneLimit;
+    private quarantineLimit;
+    private frameLimitBytes;
+    private maxInFlight;
+    private assertCanIssue;
+    private scheduleTombstoneRecycle;
+    private scheduleTombstoneRecycleIfNeeded;
+    private clearTombstoneRecycleTimer;
+    private scheduleQuarantineRecycle;
+    private maybeRecycleQuarantined;
+    private recycleQuarantinedTransport;
+    private clearQuarantineRecycleTimer;
+    private pruneIdState;
+    private handleProcessFailure;
+    private terminate;
 }