@gkorepanov/ccodex 0.3.0 → 0.4.1

package/dist/claude/service.d.ts

@@ -27,6 +27,13 @@ import type { ThreadStartResponse } from "../codex/generated/v2/ThreadStartRespo
 import type { TurnStartParams } from "../codex/generated/v2/TurnStartParams.js";
 import type { TurnStartResponse } from "../codex/generated/v2/TurnStartResponse.js";
 import type { TurnSteerParams } from "../codex/generated/v2/TurnSteerParams.js";
+import type { TurnInterruptParams } from "../codex/generated/v2/TurnInterruptParams.js";
+import type { ThreadBackgroundTerminalsCleanParams } from "../codex/generated/v2/ThreadBackgroundTerminalsCleanParams.js";
+import type { ThreadBackgroundTerminalsCleanResponse } from "../codex/generated/v2/ThreadBackgroundTerminalsCleanResponse.js";
+import type { ThreadBackgroundTerminalsListParams } from "../codex/generated/v2/ThreadBackgroundTerminalsListParams.js";
+import type { ThreadBackgroundTerminalsListResponse } from "../codex/generated/v2/ThreadBackgroundTerminalsListResponse.js";
+import type { ThreadBackgroundTerminalsTerminateParams } from "../codex/generated/v2/ThreadBackgroundTerminalsTerminateParams.js";
+import type { ThreadBackgroundTerminalsTerminateResponse } from "../codex/generated/v2/ThreadBackgroundTerminalsTerminateResponse.js";
 import type { HybridConfig } from "../config/config.js";
 import type { SubscriptionHub } from "../gateway/subscriptions.js";
 import type { Logger } from "../observability/logger.js";
@@ -34,15 +41,33 @@ import type { HybridStore } from "../store/HybridStore.js";
 import { type ClaudeQueryFactory } from "./queryFactory.js";
 import type { Model } from "../codex/generated/v2/Model.js";
 import { MetricsRegistry } from "../observability/metrics.js";
+import { type TranscriptBrancher } from "./transcriptBrancher.js";
+import { type ClaudeRateLimitStatus, type ClaudeRateLimitsResponse } from "./rateLimits.js";
+import { ShellRunner } from "./session/shellRunner.js";
+import { type ProviderAvailabilityProbe } from "../runtime/providerAvailability.js";
+import { type ThreadStateSnapshot } from "../state/stateCommand.js";
 interface ModelCatalog {
     list(): Promise<Model[]>;
     invalidate?(): void;
 }
+type PreparedGoalHandle<T> = {
+    readonly response: T;
+    notify(): Promise<void>;
+};
+type PreparedResume = {
+    readonly response: ThreadResumeResponse;
+    notifyGoalSnapshot(notify: (method: string, params: unknown) => void): Promise<void>;
+};
 export interface ClaudeHandoffSource {
     readonly thread: Thread;
     readonly turns: Turn[];
     readonly settings: ThreadSettings;
 }
+export interface ClaudeThreadAdminEffects {
+    rename(sessionId: string, name: string, cwd: string): Promise<void>;
+    delete(sessionId: string, cwd: string): Promise<void>;
+}
+export declare const EPHEMERAL_DISCONNECT_GRACE_MS: number;
 export declare class ClaudeService {
     private readonly config;
     private readonly hub;
@@ -50,36 +75,79 @@ export declare class ClaudeService {
     private readonly queryFactory;
     private readonly modelCatalog?;
     private readonly metrics;
-    private readonly runtimes;
+    private readonly transcripts;
+    private readonly threadAdminEffects;
+    private readonly availabilityProbe;
+    private readonly ephemeralReleases;
+    private readonly ephemeralReleaseTimers;
+    private readonly removalRetries;
+    private readonly terminalAdmins;
     private readonly idleTimer;
     private readonly store;
-    private readonly interactions;
+    private readonly sessionOutput;
+    private readonly sessions;
+    private readonly rateLimits;
     private idleSweep;
-    constructor(config: HybridConfig, hub: SubscriptionHub, logger: Logger, durableStore?: HybridStore, queryFactory?: ClaudeQueryFactory, modelCatalog?: ModelCatalog | undefined, metrics?: MetricsRegistry);
+    private readonly restartRecovery;
+    private closing;
+    private closePromise;
+    private standaloneStatusRead;
+    constructor(config: HybridConfig, hub: SubscriptionHub, logger: Logger, durableStore?: HybridStore, queryFactory?: ClaudeQueryFactory, modelCatalog?: ModelCatalog | undefined, metrics?: MetricsRegistry, transcripts?: TranscriptBrancher, threadAdminEffects?: ClaudeThreadAdminEffects, shellRunner?: ShellRunner, availabilityProbe?: ProviderAvailabilityProbe);
     ownsThread(threadId: string): boolean;
+    ready(): Promise<void>;
     ownsModel(modelId: string): boolean;
-    handoffSource(threadId: string, lastTurnId?: string | null): ClaudeHandoffSource;
+    readRateLimits(foregroundThreadId?: string): Promise<ClaudeRateLimitsResponse>;
+    readRateLimitStatus(foregroundThreadId?: string): Promise<ClaudeRateLimitStatus>;
+    cachedRateLimits(): ClaudeRateLimitsResponse;
+    subscribeRateLimits(connectionId: string, listener: (response: ClaudeRateLimitsResponse) => void): void;
+    unsubscribeRateLimits(connectionId: string): void;
+    handoffSource(threadId: string, lastTurnId?: string | null): Promise<ClaudeHandoffSource>;
     currentThreadSettings(threadId: string): ThreadSettings;
     loadedThreadIds(): string[];
-    reportError(threadId: string, requestedTurnId: string | undefined, message: string, codexErrorInfo: CodexErrorInfo): void;
+    reportError(threadId: string, requestedTurnId: string | undefined, message: string, codexErrorInfo: CodexErrorInfo): Promise<void>;
     startThread(params: ThreadStartParams): Promise<ThreadStartResponse>;
-    announceThread(thread: Thread): void;
+    announceThread(thread: Thread): Promise<void>;
     resumeThread(params: ThreadResumeParams | string): Promise<ThreadResumeResponse>;
+    prepareResume(params: ThreadResumeParams): Promise<PreparedResume>;
     readThread(threadId: string, includeTurns: boolean): ThreadReadResponse;
-    prepareTurn(params: TurnStartParams): Promise<{
+    prepareTurn(params: TurnStartParams, review?: {
+        label: string;
+        display: string;
+    }): Promise<{
         response: TurnStartResponse;
-        announce: () => void;
+        announce: () => Promise<void>;
         start: () => void;
+        startAndWait: () => Promise<void>;
     }>;
-    interruptTurn(threadId: string): Promise<void>;
+    prepareStatusTurn(params: TurnStartParams, render: () => Promise<string>): Promise<{
+        response: TurnStartResponse;
+        announce: () => Promise<void>;
+        start: () => void;
+    }>;
+    prepareStateTurn(params: TurnStartParams, render: () => Promise<string>): Promise<{
+        response: TurnStartResponse;
+        announce: () => Promise<void>;
+        start: () => void;
+    }>;
+    stateSnapshot(threadId: string): ThreadStateSnapshot;
+    private prepareSyntheticCommandTurn;
+    interruptTurn(value: string | TurnInterruptParams): Promise<void>;
+    cleanBackgroundTerminals(params: ThreadBackgroundTerminalsCleanParams): Promise<ThreadBackgroundTerminalsCleanResponse>;
+    listBackgroundTerminals(params: ThreadBackgroundTerminalsListParams): Promise<ThreadBackgroundTerminalsListResponse>;
+    terminateBackgroundTerminal(params: ThreadBackgroundTerminalsTerminateParams): Promise<ThreadBackgroundTerminalsTerminateResponse>;
     steerTurn(params: TurnSteerParams): Promise<{
         turnId: string;
     }>;
     compactThread(threadId: string): Promise<Record<string, never>>;
+    compactForHandoff(threadId: string, prompt?: string): Promise<string>;
+    discardHandoffThread(threadId: string): Promise<void>;
+    preparePromptedCompact(threadId: string, input: string): Promise<{
+        response: TurnStartResponse;
+        announce: () => Promise<void>;
+    }>;
     updateThreadSettings(params: ThreadSettingsUpdateParams): Promise<Record<string, never>>;
     injectItems(params: ThreadInjectItemsParams): Promise<Record<string, never>>;
     summarizeHandoff(threadId: string, prompt: string): Promise<string>;
-    createHandoffFork(params: ThreadForkParams, sourceThread: Thread, inheritedTurns: Turn[], settings: ThreadSettingsUpdateParams, developerInstructions: string, targetName: string): Promise<ThreadForkResponse>;
     shellCommand(params: ThreadShellCommandParams): Promise<Record<string, never>>;
     prepareReview(params: ReviewStartParams): Promise<{
         response: ReviewStartResponse;
@@ -91,42 +159,61 @@ export declare class ClaudeService {
     turnsPage(params: ThreadTurnsListParams): ThreadTurnsListResponse;
     listThreads(params: Parameters<HybridStore["listThreads"]>[0]): Thread[];
     setThreadName(params: ThreadSetNameParams): Promise<Record<string, never>>;
-    updateThreadMetadata(params: ThreadMetadataUpdateParams): {
+    updateThreadMetadata(params: ThreadMetadataUpdateParams): Promise<{
         thread: Thread;
-    };
+    }>;
     archiveThread(threadId: string): Promise<Record<string, never>>;
-    unarchiveThread(threadId: string): {
+    unarchiveThread(threadId: string): Promise<{
         thread: Thread;
-    };
+    }>;
     deleteThread(threadId: string): Promise<Record<string, never>>;
+    releaseEphemeralThread(threadId: string): Promise<void>;
+    scheduleEphemeralRelease(threadId: string, delayMs?: number): void;
+    cancelEphemeralRelease(threadId: string): void;
+    private releaseEphemeralThreadOnce;
     listItems(params: ThreadItemsListParams): ThreadItemsListResponse;
     forkThread(params: ThreadForkParams): Promise<ThreadForkResponse>;
     rollbackThread(params: ThreadRollbackParams): Promise<ThreadRollbackResponse>;
-    setGoal(params: ThreadGoalSetParams): {
+    prepareGoalSet(params: ThreadGoalSetParams): Promise<PreparedGoalHandle<{
         goal: ThreadGoal;
-    };
-    getGoal(threadId: string): {
+    }>>;
+    getGoal(threadId: string): Promise<{
         goal: ThreadGoal | null;
-    };
-    clearGoal(threadId: string): {
+    }>;
+    prepareGoalClear(threadId: string): Promise<PreparedGoalHandle<{
         cleared: boolean;
-    };
-    resolveServerRequest(requestId: string, response: unknown): boolean;
-    replayPendingRequests(threadId: string): void;
+    }>>;
+    private goalHandle;
+    resolveServerRequest(requestId: string, response: unknown): Promise<boolean>;
+    replayPendingRequests(threadId: string, connectionId?: string): Promise<void>;
+    eventHighWatermark(threadId: string): number;
+    eventsAfter(threadId: string, sequence: number): import("../store/HybridStore.js").StoredEvent[];
+    latestTokenUsage(threadId: string): import("../store/HybridStore.js").StoredEvent | undefined;
     close(): Promise<void>;
+    private closeOnce;
     private discardThreadSilently;
+    private removeThread;
+    private startThreadRemoval;
+    private threadAdminEffect;
+    private resumeThreadRemovals;
+    private resumeThreadRemoval;
+    private resumeThreadRemovalOnce;
+    private deleteProviderSession;
     private reconcileAfterRestart;
     private unloadIdleRuntimes;
-    private requireRuntime;
     private requireRecord;
-    private lastProviderBoundary;
-    private unloadRuntime;
+    private requireIndependentThread;
+    isChildProjection(threadId: string): boolean;
+    private assertThreadAvailable;
+    private throwPendingRemoval;
+    private pendingThreadRemoval;
+    private newThreadRecord;
     private applyTurnOverrides;
     private applySettings;
+    private validatedServiceTier;
     private validateModelSettings;
-    private threadSettings;
-    private emit;
-    private currentGoal;
-    private forkTranscript;
+    private readStandaloneRateLimitStatus;
+    private completeCommandTurn;
+    private failStatusTurnForUnload;
 }
 export {};