@leanandmean/coding-agent 0.74.1-scramjet.7 → 0.74.1-scramjet.70

package/dist/core/agent-session.d.ts

@@ -63,6 +63,7 @@ export type AgentSessionEvent = AgentEvent | {
     maxAttempts: number;
     delayMs: number;
     errorMessage: string;
+    cumulativeErrors?: number;
 } | {
     type: "auto_retry_end";
     success: boolean;
@@ -76,6 +77,7 @@ export interface AgentSessionConfig {
     sessionManager: SessionManager;
     settingsManager: SettingsManager;
     cwd: string;
+    outputThroughputHistoryPath: string;
     /** Models to cycle through with Ctrl+P (from --models flag) */
     scopedModels?: Array<{
         model: Model<any>;
@@ -160,24 +162,38 @@ export declare class AgentSession {
     readonly agent: Agent;
     readonly sessionManager: SessionManager;
     readonly settingsManager: SettingsManager;
+    readonly outputThroughputHistoryPath: string;
     private _scopedModels;
     private _unsubscribeAgent?;
     private _eventListeners;
     private _agentEventQueue;
+    private readonly _toolCostExecutions;
+    private readonly _pendingToolCosts;
+    private _historicalCostDefinitions;
+    private readonly _outputThroughputTracker;
+    private readonly _outputThroughputHistory;
+    private _outputThroughputGeneration;
+    private _latestOutputThroughputSample;
+    private _disposed;
+    private readonly _harnessPersistenceAcks;
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     private _steeringMessages;
     /** Tracks pending follow-up messages for UI display. Removed when delivered. */
     private _followUpMessages;
     /** Messages queued to be included with the next user prompt as context ("asides"). */
     private _pendingNextTurnMessages;
+    private readonly _inputSessionEntries;
     private _compactionAbortController;
+    private _manualCompactionDrain;
     private _autoCompactionAbortController;
     private _overflowRecoveryAttempted;
     private _branchSummaryAbortController;
-    private _retryAbortController;
-    private _retryAttempt;
-    private _retryPromise;
-    private _retryResolve;
+    private _retry;
+    private _runRetryCount;
+    private _activeAgentRunSettlement;
+    private _pendingAgentRunStart;
+    private readonly _unsettledAgentRuns;
+    private readonly _unsettledRetryChains;
     private _bashAbortController;
     private _pendingBashMessages;
     private _extensionRunner;
@@ -203,6 +219,7 @@ export declare class AgentSession {
     private _toolPromptGuidelines;
     private _baseSystemPromptSections;
     private _baseSystemPromptOptions;
+    private _runPromptComposition;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
     get modelRegistry(): ModelRegistry;
@@ -220,14 +237,20 @@ export declare class AgentSession {
     /** Emit an event to all listeners */
     private _emit;
     private _emitQueueUpdate;
-    private _lastAssistantMessage;
     /** Internal handler for agent events - shared by subscribe and reconnect */
     private _handleAgentEvent;
-    private _createRetryPromiseForAgentEnd;
-    private _findLastAssistantInMessages;
+    private _captureToolCost;
+    private _captureOutputThroughput;
+    private _resetOutputThroughput;
+    private _captureAgentRunSettlement;
+    private _settleAgentRun;
+    private _settleRetryChain;
+    private _completeAgentRun;
+    private _reserveAgentRunStart;
+    private _rejectAgentRunStart;
+    private _processAgentEventTracked;
+    private _harnessPersistenceAckForEvent;
     private _processAgentEvent;
-    /** Resolve the pending retry promise */
-    private _resolveRetry;
     /** Extract text content from a message */
     private _getUserMessageText;
     /** Find the last assistant message in agent state (including aborted ones) */
@@ -266,6 +289,13 @@ export declare class AgentSession {
     get isStreaming(): boolean;
     /** Current effective system prompt (includes any per-turn extension modifications), flattened to a string */
     get systemPrompt(): string;
+    get liveOutputRate(): number | undefined;
+    get outputThroughputActive(): boolean;
+    get outputThroughputGeneration(): number;
+    get medianOutputRate(): number | undefined;
+    get outputThroughputHistory(): import("./output-throughput.js").OutputThroughputHistory;
+    refreshOutputThroughputHistory(): Promise<import("./output-throughput.js").OutputThroughputHistory>;
+    flushOutputThroughputHistory(): Promise<void>;
     /** Current retry attempt (0 if not retrying) */
     get retryAttempt(): number;
     /**
@@ -296,8 +326,28 @@ export declare class AgentSession {
      * run/turn framing. The idle-vs-mid-run branch lives in `runHarnessTool` (keyed on the agent's
      * active run, which tracks `isStreaming`): idle calls execute immediately, mid-run calls queue
      * and drain before the next intra-run LLM call.
+     *
+     * **Persisted settlement (#341).** This is a strictly stronger boundary than
+     * {@link Agent.runHarnessTool}: the returned promise resolves only after (1) the Agent-core
+     * pipeline fulfills *and* (2) `_processAgentEvent` has persisted the matching tool-result
+     * `message_end` via `SessionManager.appendMessage`. Because the event queue preserves order,
+     * that also proves the preceding synthetic assistant tool-call message was persisted first. It
+     * rejects on Agent-core failure, on failure to process/persist a matching event, on disposal
+     * before settlement, on a post-disposal call, on an unknown tool, or on a duplicate explicit
+     * tool-call id that is already pending. **Rejection means the promised pipeline did not complete —
+     * it does not prove artifact absence** (Agent state and persistence may have partially or fully
+     * completed before a late failure), so callers must not blindly retry. A tool's own `execute()`
+     * error is *not* a rejection: it becomes a normal `isError: true` result and the promise resolves
+     * after that error-result pipeline is persisted.
+     *
+     * **Reentrancy.** As with `runHarnessTool`, do not `await` this from work whose return is required
+     * for the Agent to reach the drain point or for the event queue to persist the matching result.
      */
     invokeHarnessTool(name: string, args: unknown, options?: InvokeHarnessToolOptions): Promise<void>;
+    private _allocateHarnessToolCallId;
+    private _completeHarnessToolInvocation;
+    private _settleHarnessPersistenceAck;
+    private _registerHarnessPersistenceAck;
     /** Whether compaction or branch summarization is currently running */
     get isCompacting(): boolean;
     /** All messages including custom types like BashExecutionMessage */
@@ -326,6 +376,7 @@ export declare class AgentSession {
     get promptTemplates(): ReadonlyArray<PromptTemplate>;
     private _normalizePromptSnippet;
     private _normalizePromptGuidelines;
+    private _applyRunPromptComposition;
     /** Rebuild `_baseSystemPromptSections` from the current resources and tool set and apply it to agent state. */
     private _rebuildSystemPrompt;
     /**
@@ -505,16 +556,28 @@ export declare class AgentSession {
     private _refreshToolRegistry;
     private _buildRuntime;
     reload(): Promise<void>;
-    /**
-     * Check if an error is retryable (overloaded, rate limit, server errors).
-     * Context overflow errors are NOT retryable (handled by compaction instead).
-     */
-    private _isRetryableError;
+    private _classifyRetry;
+    private _isLegacyRetryableError;
+    private _bounded;
+    private _appendAutoRetryRecord;
+    /**
+     * Persist a terminal record, emit `auto_retry_end` when a retry phase was active, and clear the phase.
+     * The phase is released before persistence is attempted so a persistence failure can never strand it.
+     */
+    private _finishRetry;
+    private _finishRetryWithoutSuccess;
+    /** A run that ends without a classifiable snapshot cannot continue the retry; close it so nothing stays wedged. */
+    private _releaseRetryForFailedRun;
+    private _reportRetryFailure;
     private _handleRetryableError;
+    private _finishCancelledRetry;
     /**
      * Cancel in-progress retry.
      */
     abortRetry(): void;
+    /** Agent's own `activeRun` guard is false during backoff; the retry phase owns the idle Agent then. */
+    private _assertRetryNotOwningIdleAgent;
+    private _runAgentPrompt;
     private waitForRetry;
     /** Whether auto-retry is currently in progress */
     get isRetrying(): boolean;
@@ -589,7 +652,7 @@ export declare class AgentSession {
         entryId: string;
         text: string;
     }>;
-    private _extractUserMessageText;
+    getRecordedSessionCost(): number;
     /**
      * Get session statistics.
      */