@gkorepanov/ccodex 0.3.0 → 0.3.4

package/dist/claude/session/session.d.ts

@@ -0,0 +1,281 @@
+import type { Turn } from "../../codex/generated/v2/Turn.js";
+import type { ClaudeSessionHandle } from "../sessionRegistry.js";
+import { MetricsRegistry } from "../../observability/metrics.js";
+import type { ClaudeSessionCommand, PreparedSessionTurn, RuntimeInspection, SessionLifecycleUpdate } from "./commands.js";
+import type { ClaudeOutputAdapter } from "./outputAdapter.js";
+import { type ClaudeSessionRepository } from "./repository.js";
+import { ShellRunner } from "./shellRunner.js";
+import { type BackgroundOutputReader } from "./backgroundOutput.js";
+import type { TurnStartParams } from "../../codex/generated/v2/TurnStartParams.js";
+import type { TurnSteerParams } from "../../codex/generated/v2/TurnSteerParams.js";
+import type { ThreadBackgroundTerminal } from "../../codex/generated/v2/ThreadBackgroundTerminal.js";
+import type { JsonValue } from "../../codex/generated/serde_json/JsonValue.js";
+import type { Logger } from "../../observability/logger.js";
+import type { ClaudeQueryFactory } from "../queryFactory.js";
+import type { TranscriptBrancher } from "../transcriptBrancher.js";
+import type { ClaudeRateLimitCoordinator } from "../rateLimits.js";
+export interface ClaudeSessionRuntimeDependencies {
+    readonly claudeBinary: string;
+    readonly logger: Logger;
+    readonly queryFactory: ClaudeQueryFactory;
+    readonly transcripts: TranscriptBrancher;
+    readonly rateLimits: ClaudeRateLimitCoordinator;
+    readonly invalidateModelCatalog: () => void;
+    readonly isClosing: () => boolean;
+}
+export interface PreparedRuntimeTurn {
+    readonly messageUuid: string;
+    readonly readOnly: boolean;
+    discard(): Promise<void>;
+    attach(turn: PreparedSessionTurn["turn"]): () => Promise<void>;
+}
+export declare class ClaudeSession implements ClaudeSessionHandle<ClaudeSessionCommand> {
+    private readonly threadId;
+    private readonly repository;
+    private readonly output;
+    private readonly metrics;
+    private readonly onLifecycle;
+    private readonly onChildCreated;
+    private readonly onChildRemoved;
+    private readonly shellRunner;
+    private readonly backgroundOutputReader;
+    private readonly runtimeDependencies?;
+    private readonly mailbox;
+    private readonly consumer;
+    private runtimeLineage;
+    private nextRuntimeGeneration;
+    private runtimeAdminOperations;
+    private runtimeAdminIdle;
+    private runtimeInjectionOperations;
+    private runtimeInjectionIdle;
+    private runtimeReplacement;
+    private readonly announcedTurns;
+    private readonly announcedInteractions;
+    private readonly interactionWaiters;
+    private record;
+    private runtimeGeneration;
+    private readonly scopes;
+    private readonly tasks;
+    private readonly approvedTools;
+    private compaction;
+    private readonly compactionActions;
+    private lastPublishedUsage;
+    private lifecycle;
+    private pendingNoQuery;
+    private pendingInputs;
+    private readonly stagedRuntimeTurns;
+    private readonly preparedRuntimeInputs;
+    private readonly runtimeInjections;
+    private hasSubmittedRuntimeInput;
+    private providerError;
+    private readonly goalUsageEvents;
+    private goalCommandTokensObserved;
+    private usageSnapshotGeneration;
+    private rootReadOnly;
+    private interruptFence;
+    private transportStopFence;
+    private dropLateFacts;
+    private continuationTimer;
+    private lastQuiescent;
+    private lastActivityMs;
+    private lastAcceptProviderFacts;
+    private readonly goal;
+    private readonly hookRuns;
+    private hookDisplayOrder;
+    private adminOperation;
+    private shell;
+    constructor(threadId: string, repository: ClaudeSessionRepository, output: ClaudeOutputAdapter, capacity?: number, metrics?: MetricsRegistry, onLifecycle?: (update: SessionLifecycleUpdate) => void, onChildCreated?: (threadId: string) => void, onChildRemoved?: (threadId: string) => void, shellRunner?: ShellRunner, backgroundOutputReader?: BackgroundOutputReader, runtimeDependencies?: ClaudeSessionRuntimeDependencies | undefined);
+    submit<Result>(command: ClaudeSessionCommand): Promise<Result>;
+    private submitLineage;
+    private submitRuntimeEffect;
+    private beginRuntimeReplacement;
+    get isLoaded(): boolean;
+    ensureRuntime(reinitialize?: boolean): Promise<void>;
+    materializeRuntime(): Promise<void>;
+    prepareRuntimeTurn(params: TurnStartParams, readOnly?: boolean): Promise<PreparedRuntimeTurn>;
+    interruptRuntime(expectedTurnId?: string): Promise<void>;
+    fenceCurrentRuntimeStop(expectedTurnId?: string): Promise<boolean>;
+    interruptChildRuntime(childThreadId: string, expectedTurnId?: string): Promise<void>;
+    listBackgroundTerminals(ownerThreadId: string): Promise<ThreadBackgroundTerminal[]>;
+    cleanBackgroundTerminals(ownerThreadId: string): Promise<void>;
+    terminateBackgroundTerminal(ownerThreadId: string, processId: string): Promise<boolean>;
+    steerRuntime(params: TurnSteerParams): Promise<string>;
+    compactRuntime(): Promise<void>;
+    preparePromptedCompaction(input: string): Promise<{
+        turn: Turn;
+        announce: () => Promise<void>;
+    }>;
+    injectRuntimeItems(items: JsonValue[], waitForAcknowledgement?: boolean): Promise<void>;
+    runtimeInspection(): Promise<(RuntimeInspection & {
+        runtimeGeneration: number;
+    }) | undefined>;
+    runtimeIsPlanMode(): Promise<boolean>;
+    replaceEphemeralRuntime(replay: {
+        readonly resume: boolean;
+        readonly batches: JsonValue[][];
+    }, replacementId?: string): Promise<void>;
+    ephemeralRuntimeReplay(): Promise<{
+        readonly canRestart: boolean;
+        readonly replay?: {
+            readonly resume: boolean;
+            readonly batches: JsonValue[][];
+        };
+    }>;
+    retireRuntime(reason?: string): Promise<void>;
+    retireRuntimeSilently(): Promise<void>;
+    retireRuntimeIfIdle(milliseconds: number): Promise<"retired" | "ephemeral" | "busy" | "absent">;
+    mayRelease(): Promise<boolean>;
+    withRuntimeAdmin<Result>(effect: () => Promise<Result>): Promise<Result>;
+    private withRuntimeInjection;
+    close(): Promise<void>;
+    private requireRuntimeOwner;
+    private currentRuntimeOwner;
+    private runtimeStartup;
+    private createRuntimeGeneration;
+    private waitForProviderRuntime;
+    private applyRuntimeSettings;
+    private runtimeInspectionFor;
+    private canRestartEphemeral;
+    private runtimeIdleFor;
+    private invalidateRuntimeUsageSnapshot;
+    private stageRuntimeTurn;
+    private discardRuntimeTurn;
+    private attachRuntimeTurn;
+    private steerRuntimeOwner;
+    private injectHiddenGoalPrompt;
+    private injectRuntimeItemsIntoOwner;
+    private sendPreparedRuntimeInput;
+    private interruptRuntimeOwner;
+    private interruptChildRuntimeOwner;
+    private listRuntimeBackgroundTerminals;
+    private terminateRuntimeBackgroundTerminal;
+    private applyRuntimeMainStream;
+    private injectRuntimeItemsForOwner;
+    private admitRuntimeOperation;
+    private completeRuntimeGeneration;
+    private runtimeExited;
+    private submitProviderProjection;
+    private handleProviderFact;
+    private projectProviderMessage;
+    private cancelProviderInjections;
+    private openProviderInteraction;
+    private providerCallbackContext;
+    private providerInteractionOwner;
+    private applyProviderMainStream;
+    private canUseProviderTool;
+    private askProviderUser;
+    private handleProviderElicitation;
+    private beforeProviderToolUse;
+    private captureProviderFileAfter;
+    private providerFactSource;
+    private providerChildThreadFor;
+    private providerLinkItems;
+    private providerEvictMessages;
+    private providerSystemMessage;
+    private providerChildStreamEvent;
+    private providerProjectAssistant;
+    private providerProjectToolResults;
+    private providerToolProgress;
+    private providerSubmitLifecycle;
+    private providerSubmitCompactionFailure;
+    private providerCompactionBoundary;
+    private claimProviderUsageSnapshot;
+    private providerUsageSnapshotCurrent;
+    private publishProviderUsage;
+    private accountProviderUsage;
+    private resolveProviderResultUsage;
+    private resolveProviderCompactionUsage;
+    private accountProviderGoalUsage;
+    private providerMainStreamEvent;
+    private stopProviderRuntime;
+    private retireProviderRuntimeSilently;
+    private retireProviderEphemeralPrelude;
+    private refreshProviderContextUsage;
+    private retireRuntimeOwner;
+    private executeRetirement;
+    private retireStaleRuntime;
+    private run;
+    private dispatchEnvelope;
+    private dispatch;
+    private startShell;
+    private runShell;
+    private admitShellEffect;
+    private appendShellOutput;
+    private finishShell;
+    private prepareShellCancellation;
+    private cancelShell;
+    private finalizeShellCancellation;
+    private startCompaction;
+    private announceCompaction;
+    private interruptCompaction;
+    private requestCompactionCancellation;
+    private projectAutomaticCompaction;
+    private completeCompaction;
+    private compactionProjection;
+    private activeNormalTurn;
+    private startTurn;
+    private recoverAfterRestart;
+    private recoverTurn;
+    private recoveredItemEvents;
+    private announceTurn;
+    private terminalTurn;
+    private finishTurn;
+    private goalContext;
+    private planMode;
+    private validateLiveEphemeralSettings;
+    private acceptLifecycle;
+    private maybeFinish;
+    private hasNotifications;
+    private hasBlockers;
+    private settleForcedScopes;
+    private emitLifecycle;
+    private publishGoalEffects;
+    private executeCompactionTransport;
+    private executeGoalEffect;
+    private isQuiescent;
+    private scheduleContinuation;
+    private cancelContinuation;
+    private settleRootMessages;
+    private appendReviewExit;
+    private settleInteraction;
+    private interactionWaiter;
+    private dispatchThreadAdmin;
+    private prepareRemoval;
+    private afterShellCancellation;
+    private findTool;
+    private toolOwner;
+    private captureToolFileBefore;
+    private captureToolFileAfter;
+    private acceptHook;
+    private syncInteractionStatus;
+    private inspectRuntime;
+    private appendSystemNotice;
+    private projectMainStream;
+    private projectToolFact;
+    private evictProjectedItems;
+    private ensureBackgroundTailer;
+    private drainBackgroundOutput;
+    private completeTaskAfterOutputDrain;
+    private stopBackgroundTailer;
+    private disposeRuntimeOperations;
+    private cancelRuntimeInjections;
+    private hasOutputDrains;
+    private projectTaskFact;
+    private updateTool;
+    private beginTool;
+    private completeTool;
+    private createChildScope;
+    private finishChildScope;
+    private reconcileAssistant;
+    private ensureStreamItem;
+    private settleAgentMessages;
+    private completeStreamItem;
+    private requireMainStreamState;
+    private requireRecord;
+    private usageKey;
+    private commitState;
+    private publish;
+    private publishTurn;
+    private publishOwnedTurn;
+    private publishAt;
+}