turboflux 1.0.0

package/dist/core/agentEngine.d.ts

@@ -0,0 +1,425 @@
+import type { AgentMode, AgentSession, AgentTurn, AgentConfig, ContextPolicyMode, ToolCall, ToolResult, TokenUsage, AgentRunState } from '../shared/agentTypes';
+import { TaskManager, type TaskTreeNode } from './taskManager';
+import type { TerminalSessionInfo } from '../shared/terminalTypes';
+import type { RuntimeTask } from '../shared/runtimeTaskTypes';
+import type { McpClient } from './mcp/client';
+import type { SubAgentEvent } from '../shared/subAgentTypes';
+import { type ModelProtocol } from './modelProtocol';
+import type { ToolExecutor } from '../tools/executor';
+import type { AgentStateProvider, ContextReservoirEntry, ContextSegment } from '../state/types';
+import { type GitIntegrationState } from './gitService';
+import { SubAgentTaskManager } from './runtime/subAgentTaskManager';
+type TaskSystemCreationEvent = {
+    status: 'planning' | 'creating' | 'completed' | 'error';
+    toolName?: string;
+    expectedCount?: number;
+    createdCount?: number;
+    title?: string;
+    startedAt?: number;
+    updatedAt: number;
+    error?: string;
+};
+export declare function splitTurnsForCompaction(turns: AgentTurn[], keepRecent: number): {
+    oldTurns: AgentTurn[];
+    recentTurns: AgentTurn[];
+};
+export declare function extractResponsesReasoningSummary(output: unknown): string;
+export declare function extractResponsesReasoningEventDelta(event: unknown): string;
+export declare function normalizeAnthropicToolMessages(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>>;
+type PromptModuleSnapshot = {
+    id: string;
+    label: string;
+    hash: string;
+    chars: number;
+    stable: boolean;
+};
+export type AgentEventType = {
+    type: 'run:state';
+    state: AgentRunState;
+} | {
+    type: 'turn:start';
+    turn: AgentTurn;
+} | {
+    type: 'turn:complete';
+    turn: AgentTurn;
+} | {
+    type: 'tool:call';
+    toolCall: ToolCall;
+} | {
+    type: 'tool:result';
+    toolResult: ToolResult;
+} | {
+    type: 'task:update';
+    taskId: string;
+    status: string;
+    progress: number;
+} | {
+    type: 'mode:change';
+    from: AgentMode;
+    to: AgentMode;
+} | {
+    type: 'session:complete';
+    session: AgentSession;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'notification';
+    message: string;
+    level: 'info' | 'success' | 'warning' | 'error';
+} | {
+    type: 'model:protocol';
+    phase: 'attempt' | 'fallback' | 'success';
+    protocol: ModelProtocol;
+    url: string;
+    message?: string;
+} | {
+    type: 'stream:delta';
+    text: string;
+} | {
+    type: 'stream:thinking_delta';
+    text: string;
+} | {
+    type: 'stream:tool_call_delta';
+    toolCallId: string;
+    toolName: string;
+    partialJson: string;
+} | {
+    type: 'stream:start';
+} | {
+    type: 'stream:end';
+    interrupted?: boolean;
+} | {
+    type: 'stream:usage';
+    usage: TokenUsage;
+} | {
+    type: 'ask:user';
+    question: string;
+    options?: string[];
+    reason?: string;
+    command?: string;
+    requestId?: string;
+    toolName?: string;
+    path?: string;
+    queuedCount?: number;
+} | {
+    type: 'approval:state';
+    requestId: string;
+    requestKind: 'permission' | 'input';
+    state: 'requested' | 'resolved' | 'cancelled';
+    decision?: string;
+    question: string;
+    toolName?: string;
+    path?: string;
+} | {
+    type: 'input:state';
+    inputId: string;
+    intent: 'steer';
+    state: 'accepted' | 'committed' | 'rejected';
+    text: string;
+    reason?: string;
+} | {
+    type: 'active:task';
+    context: import('./taskManager').ActiveTaskContext | null;
+} | {
+    type: 'terminal:sessions';
+    sessions: TerminalSessionInfo[];
+} | {
+    type: 'runtime-task:finished';
+    task: RuntimeTask;
+} | {
+    type: 'task:system';
+    context: import('./taskManager').ActiveTaskContext | null;
+    tree: TaskTreeNode[];
+    creation?: TaskSystemCreationEvent | null;
+} | {
+    type: 'context:segment_created';
+    segment: ContextSegment;
+} | {
+    type: 'git:state';
+    state: GitIntegrationState;
+} | {
+    type: 'subagent:start';
+    agentId: string;
+    agentType: string;
+    label: string;
+    objective: string;
+} | {
+    type: 'subagent:progress';
+    agentId: string;
+    agentType: string;
+    label: string;
+    event: SubAgentEvent;
+} | {
+    type: 'subagent:end';
+    agentId: string;
+    agentType: string;
+    ok: boolean;
+    elapsedMs: number;
+} | {
+    type: 'cache:diagnostic';
+    result: {
+        broken: boolean;
+        reason: string;
+        tokenDrop: number;
+        likelyTtlExpiry: boolean;
+    };
+} | {
+    type: 'cache:modules';
+    modules: PromptModuleSnapshot[];
+};
+export type AgentEventListener = (event: AgentEventType) => void;
+export type AgentEventRecorder = (event: AgentEventType) => void;
+type AskUserEvent = Extract<AgentEventType, {
+    type: 'ask:user';
+}>;
+interface EngineInteractiveRequest {
+    id: string;
+    kind: 'permission' | 'input';
+    event: AskUserEvent;
+}
+export { downgradeReasoningEffort } from './requestCompatibility';
+export declare function appendRuntimeContextToLatestUserMessage(messages: Array<Record<string, unknown>>, text: string, provider: 'openai' | 'anthropic'): boolean;
+export declare class AgentEngine {
+    private config;
+    private session;
+    private taskManager;
+    private listeners;
+    private eventRecorder;
+    private abortController;
+    private currentStreamId;
+    private isPaused;
+    private pausePromise;
+    private pauseResolve;
+    private unsubscribeTaskManager;
+    private contextManager;
+    private readonly interactiveRequests;
+    private readonly resolvedAskUserResponses;
+    private toolCallTaskMap;
+    private fileBeforeSnapshots;
+    private agentBackgroundSessions;
+    private turnStrategyPlanner;
+    private currentTurnStrategy;
+    private workspaceSkeleton;
+    private workspaceSkeletonPath;
+    private cachedGitStatus;
+    private gitDetected;
+    private gitGeneration;
+    private gitState;
+    private workspaceMemoryText;
+    private workspaceMemoryWorkspace;
+    private workspaceMemoryBuiltAt;
+    private cacheMonitor;
+    private permissions;
+    private preservedFiles;
+    private compressionPreparedTurnCount;
+    private currentRunToolNames;
+    private currentRunReadFiles;
+    private currentRunSuccessfulReadFiles;
+    private currentRunSearches;
+    private currentRunSuccessfulSearches;
+    private toolExecutionLedger;
+    private conclusionGuardAttempts;
+    private disabledToolNames;
+    private pendingAssistantMessageId;
+    private currentRunPromise;
+    private pendingSteeringMessages;
+    private steeringOpen;
+    private runState;
+    private forceContextCompactionBeforeNextCall;
+    private contextLimitRetryInProgress;
+    private toolExecutor;
+    private stateProvider;
+    private subAgentTaskManager;
+    private mcpClient;
+    private deferredMcpToolNames;
+    setMcpClient(client: McpClient): void;
+    setEventRecorder(recorder: AgentEventRecorder | null): void;
+    constructor(config: AgentConfig, toolExecutor: ToolExecutor, stateProvider: AgentStateProvider, subAgentTaskManager?: SubAgentTaskManager);
+    destroy(): void;
+    getMode(): AgentMode;
+    setMode(mode: AgentMode): void;
+    setAppendSystemPrompt(appendSystemPrompt: string | undefined): void;
+    setConversationId(conversationId: string): void;
+    getConversationId(): string | undefined;
+    updateRuntimeConfiguration(update: Partial<Pick<AgentConfig, 'approvalPolicy' | 'capabilityProfile' | 'gitEnabled' | 'contextWindow' | 'maxTokens' | 'profileSystemPrompt'>>): void;
+    setEnabledSkills(skills: AgentConfig['enabledSkills']): void;
+    reloadAgents(): void;
+    isRunning(): boolean;
+    setContextPolicy(mode: ContextPolicyMode): void;
+    setApprovalPolicy(policy: NonNullable<AgentConfig['approvalPolicy']>): void;
+    getApprovalPolicy(): NonNullable<AgentConfig['approvalPolicy']>;
+    getGitState(): GitIntegrationState;
+    setGitEnabled(enabled: boolean): void;
+    initializeGit(force?: boolean): Promise<boolean>;
+    private invalidateStaticPromptCache;
+    refreshGitStatus(expectedGeneration?: number): Promise<void>;
+    private updateGitState;
+    private runGitOperation;
+    compactContext(): Promise<void>;
+    getTokenUsage(): {
+        input: number;
+        output: number;
+    };
+    getContextUsage(): TokenUsage;
+    getContextSegments(): ContextSegment[];
+    setContextSegments(segments: ContextSegment[]): void;
+    getContextReservoir(): ContextReservoirEntry[];
+    setContextReservoir(entries: ContextReservoirEntry[]): void;
+    getFullConversationTurns(): AgentTurn[];
+    resetSession(): void;
+    restoreFromTurns(turns: AgentTurn[]): void;
+    setDisabledTools(toolNames: string[]): void;
+    private modelDisabledToolNames;
+    attachPendingAssistantMessageId(messageId: string): void;
+    getSession(): AgentSession;
+    getTaskManager(): TaskManager;
+    resetContextTracking(): void;
+    restoreFromMessages(messages: Array<{
+        id?: string;
+        role: string;
+        content: string;
+        timestamp?: number;
+        metadata?: {
+            model?: string;
+            tokens?: number | TokenUsage;
+            duration?: number;
+            reasoningEnabled?: boolean;
+            reasoningEffort?: NonNullable<AgentTurn['metadata']>['reasoningEffort'];
+            thinking?: NonNullable<AgentTurn['metadata']>['thinking'];
+            rawReasoningPayload?: NonNullable<AgentTurn['metadata']>['rawReasoningPayload'];
+            attachments?: NonNullable<AgentTurn['metadata']>['attachments'];
+            runtimeContext?: string;
+            toolCalls?: Array<{
+                id?: string;
+                name: string;
+                arguments: Record<string, unknown>;
+                result?: string;
+                isError?: boolean;
+                status?: string;
+                changeSummary?: {
+                    path: string;
+                    operation: 'write' | 'edit' | 'delete';
+                    addedLines?: number;
+                    removedLines?: number;
+                    totalLines?: number;
+                    preview?: string;
+                    oldPreview?: string;
+                    before?: string;
+                    after?: string;
+                };
+            }>;
+            detectedSkills?: string[];
+            isStreaming?: boolean;
+        };
+    }>): void;
+    private restoreTasksFromToolCalls;
+    private isRestorableTaskToolCall;
+    subscribe(listener: AgentEventListener): () => void;
+    getRunState(): AgentRunState;
+    private setRunState;
+    submitSteeringMessage(message: string, inputId?: string): boolean;
+    private consumeSteeringMessages;
+    private rejectPendingSteeringMessages;
+    publishRuntimeTaskFinished(task: RuntimeTask): void;
+    abort(): void;
+    submitAskUserResponse(response: string, requestId?: string): boolean;
+    getPendingInteractiveRequests(): {
+        active: EngineInteractiveRequest | null;
+        queued: EngineInteractiveRequest[];
+        pendingCount: number;
+    };
+    pause(): void;
+    resume(): void;
+    private waitIfPaused;
+    private isContextLimitError;
+    private prepareContextWindow;
+    private currentContextWindowSettings;
+    private providerContextTokens;
+    private shouldCompactFromProviderUsage;
+    private shouldCompactFromLocalSize;
+    private currentContextTokensWithTokenizerTail;
+    private findLastProviderUsageTurnIndex;
+    waitUntilIdle(): Promise<void>;
+    run(userMessage: string, options?: {
+        reuseLastUserTurn?: boolean;
+        attachments?: NonNullable<AgentTurn['metadata']>['attachments'];
+        userTurnId?: string;
+    }): Promise<AgentTurn[]>;
+    private ensureContextWindow;
+    private performContextCompaction;
+    private generateContinuationSummary;
+    private requestContinuationSummary;
+    private countTurnChars;
+    private collectPreservedFiles;
+    private addReservoirEntry;
+    private pruneContextReservoir;
+    private autoClearStaleToolResults;
+    private buildToolRetryHint;
+    private attachToolRetryHint;
+    private captureBeforeSnapshot;
+    private buildDiffSnapshot;
+    private callModel;
+    private callAnthropicAPI;
+    private tryParsePartialJson;
+    private buildOpenAITools;
+    private callOpenAICompatibleAPI;
+    private callOpenAIResponsesAPI;
+    private wrapRuntimeContextSection;
+    private captureRuntimeContext;
+    private buildPromptCacheKey;
+    private emitPromptModuleSnapshot;
+    private appendTextAtConversationTail;
+    private injectPreservedFilesIntoMessages;
+    private buildApiMessages;
+    private buildContextCandidateTurns;
+    private enforceFinalMessageBudget;
+    private withAnthropicMessageCacheControl;
+    private withOpenRouterCacheControl;
+    private withLastMessageCacheControl;
+    private withRecentMessageCacheControl;
+    private addCacheControlToMessage;
+    private extractStructuredReasoningDelta;
+    private maybeBuildWorkspaceSkeleton;
+    private maybeRefreshWorkspaceMemory;
+    private buildEvidenceGuardHint;
+    private buildEvidencePolicyContext;
+    private recordToolUsage;
+    private recordSuccessfulToolUsage;
+    private isToolOutputFailure;
+    private getTaskToolStatus;
+    private replayEvidenceFromExistingTurns;
+    private executeToolCalls;
+    private executeToolsConcurrently;
+    private linkToolCallToActiveTask;
+    private updateTaskToolCallStatus;
+    private emitActiveTaskContext;
+    private emitTerminalSessions;
+    private getTerminalSession;
+    private emitTaskSystem;
+    private extractToolCallPath;
+    private isWriteToolCall;
+    private resolveToolDefinition;
+    private isReadAfterWriteSensitiveToolCall;
+    private partitionToolCalls;
+    private executeSingleTool;
+    private executeSingleToolUncached;
+    private classifyToolErrorKind;
+    private checkToolPermission;
+    private parsePermissionDecision;
+    private emitSubAgentProgress;
+    private formatSubAgentTask;
+    private dispatchTool;
+    private formatContentSearchResults;
+    private formatCodeSearchHits;
+    private formatCodeMap;
+    private formatWebSearchResults;
+    private resolvePath;
+    private toWorkspaceRelative;
+    private createUserTurn;
+    private createAssistantTurn;
+    private finishInterruptedStream;
+    private createToolResultTurn;
+    private createMockTurn;
+    private emit;
+}