@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/core/orchestrator-turn-loop.js

@@ -0,0 +1,319 @@
+import { ConsecutiveErrorBreaker } from '@pellux/goodvibes-sdk/platform/core/circuit-breaker';
+import { estimateConversationTokens, estimateTokens } from './context-compaction.js';
+import { ProviderError, isNonTransientProviderFailure } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { formatProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { emitOpsCacheMetrics, emitOpsHelperUsage, emitLlmResponseReceived, emitPreflightFail, emitPreflightOk, emitStreamDelta, emitStreamEnd, emitStreamStart, emitTurnError, } from '../runtime/emitters/index.js';
+import { HelperModel } from '../config/helper-model.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { emitMalformedToolUseWarning, handleFinalResponseOutcome, handleToolResponseOutcome, } from './orchestrator-turn-helpers.js';
+const AUTO_SPAWN_FALLBACK_DELAY_MS = 5_000;
+export async function executeOrchestratorTurnLoop(context) {
+    const helperModel = context.helperModel;
+    const model = context.providerRegistry.getCurrentModel();
+    const provider = model.provider
+        ? context.providerRegistry.get(model.provider)
+        : context.providerRegistry.getForModel(model.id);
+    const toolDefinitions = context.toolRegistry.getToolDefinitions();
+    const streamEnabled = context.configManager.get('display.stream');
+    let continueLoop = true;
+    const circuitBreaker = new ConsecutiveErrorBreaker();
+    while (continueLoop) {
+        let streamAccumulated = '';
+        let reasoningAccumulated = '';
+        let streamSessionStarted = false;
+        const onDelta = (delta) => {
+            if (delta.content) {
+                streamAccumulated += delta.content;
+                if (streamEnabled) {
+                    context.conversation.updateStreamingBlock(streamAccumulated);
+                }
+            }
+            if (delta.reasoning) {
+                reasoningAccumulated += delta.reasoning;
+            }
+            if (delta.content || delta.reasoning) {
+                context.addStreamingOutputTokens(Math.max(1, estimateTokens(delta.content ?? delta.reasoning ?? '')));
+            }
+            if (context.runtimeBus) {
+                emitStreamDelta(context.runtimeBus, context.emitterContext(context.turnId), {
+                    turnId: context.turnId,
+                    content: delta.content ?? '',
+                    accumulated: streamAccumulated,
+                    ...(delta.reasoning !== undefined ? { reasoning: delta.reasoning } : {}),
+                    ...(delta.toolCalls !== undefined ? { toolCalls: delta.toolCalls } : {}),
+                });
+            }
+            context.requestRender();
+        };
+        const preflightResult = await context.checkContextWindowPreflight(context.turnId, model);
+        if (preflightResult === 'error') {
+            if (streamEnabled) {
+                context.setStreamingActive(false);
+                context.conversation.finalizeStreamingBlock();
+            }
+            if (context.runtimeBus) {
+                emitStreamEnd(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
+                emitPreflightFail(context.runtimeBus, context.emitterContext(context.turnId), {
+                    turnId: context.turnId,
+                    reason: 'context window preflight failed',
+                    stopReason: 'context_overflow',
+                });
+            }
+            context.markTurnFailed();
+            break;
+        }
+        if (context.runtimeBus) {
+            emitPreflightOk(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
+        }
+        context.setStreamingInputTokens(context.estimateFreshTurnInputTokens(estimateConversationTokens(context.conversation.getMessagesForLLM()), context.text, context.content));
+        if (streamEnabled) {
+            context.setStreamingActive(true);
+            context.conversation.startStreamingBlock();
+        }
+        if (context.runtimeBus) {
+            emitStreamStart(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
+        }
+        streamSessionStarted = true;
+        const tokenLimits = context.providerRegistry.getTokenLimitsForModel(model);
+        if (context.hookDispatcher) {
+            const preEvent = {
+                path: 'Pre:llm:chat',
+                phase: 'Pre',
+                category: 'llm',
+                specific: 'chat',
+                sessionId: context.sessionId,
+                timestamp: Date.now(),
+                payload: { model: model.id, provider: model.provider, messageCount: context.conversation.getMessagesForLLM().length },
+            };
+            const preResult = await context.hookDispatcher.fire(preEvent);
+            if (preResult.decision === 'deny') {
+                context.conversation.addSystemMessage(preResult.reason ?? 'LLM call blocked by hook');
+                if (context.runtimeBus) {
+                    emitTurnError(context.runtimeBus, context.emitterContext(context.turnId), {
+                        turnId: context.turnId,
+                        error: preResult.reason ?? 'LLM call blocked by hook',
+                        stopReason: 'hook_denied',
+                    });
+                }
+                context.markTurnFailed();
+                break;
+            }
+        }
+        let response;
+        try {
+            response = await provider.chat({
+                model: model.id,
+                messages: context.conversation.getMessagesForLLM(),
+                tools: toolDefinitions.length > 0 ? toolDefinitions : undefined,
+                systemPrompt: context.getSystemPrompt(),
+                maxTokens: tokenLimits.maxOutputTokens,
+                reasoningEffort: (() => {
+                    const configured = context.configManager.get('provider.reasoningEffort');
+                    if (configured)
+                        return configured;
+                    return model.capabilities.reasoning ? 'medium' : undefined;
+                })(),
+                signal: context.getAbortSignal(),
+                onDelta,
+            });
+        }
+        catch (chatErr) {
+            if (streamEnabled) {
+                context.setStreamingActive(false);
+                context.conversation.finalizeStreamingBlock();
+            }
+            if (streamSessionStarted && context.runtimeBus) {
+                emitStreamEnd(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
+            }
+            if (chatErr instanceof ProviderError && chatErr.statusCode === 429 && model.provider === 'synthetic' && model.tier !== 'free') {
+                context.conversation.addSystemMessage(`All providers for ${model.displayName} are currently exhausted.\n`
+                    + `Options:\n`
+                    + `  • Wait a few minutes for the rate limit to reset and retry\n`
+                    + `  • Switch to a different model with /model\n`
+                    + `  • Switch to a free model via /model and selecting the free tier`);
+                if (context.runtimeBus) {
+                    emitTurnError(context.runtimeBus, context.emitterContext(context.turnId), {
+                        turnId: context.turnId,
+                        error: 'All providers for the selected synthetic model are exhausted',
+                        stopReason: 'provider_exhausted',
+                    });
+                }
+                context.markTurnFailed();
+                context.requestRender();
+                break;
+            }
+            if (context.hookDispatcher) {
+                context.hookDispatcher.fire({
+                    path: 'Fail:llm:chat',
+                    phase: 'Fail',
+                    category: 'llm',
+                    specific: 'chat',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    payload: { model: model.id, provider: model.provider, error: chatErr instanceof Error ? chatErr.message : String(chatErr) },
+                }).catch(() => { });
+            }
+            throw chatErr;
+        }
+        if (streamEnabled) {
+            context.setStreamingActive(false);
+            context.conversation.finalizeStreamingBlock();
+        }
+        if (streamSessionStarted && context.runtimeBus) {
+            emitStreamEnd(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
+        }
+        response = {
+            ...response,
+            usage: context.normalizeUsage(response.usage),
+        };
+        void context.favoritesStore?.recordUsage(model.id);
+        context.usage.input += response.usage.inputTokens;
+        context.usage.output += response.usage.outputTokens;
+        context.usage.cacheRead += response.usage.cacheReadTokens ?? 0;
+        context.usage.cacheWrite += response.usage.cacheWriteTokens ?? 0;
+        const cacheMetrics = context.cacheHitTracker.getMetrics();
+        if (cacheMetrics.turns > 0 && context.runtimeBus) {
+            emitOpsCacheMetrics(context.runtimeBus, context.emitterContext(context.turnId), {
+                hitRate: cacheMetrics.hitRate,
+                cacheReadTokens: cacheMetrics.cacheReadTokens,
+                cacheWriteTokens: cacheMetrics.cacheWriteTokens,
+                totalInputTokens: cacheMetrics.totalInputTokens,
+                turns: cacheMetrics.turns,
+            });
+        }
+        const helperUsage = helperModel.getUsage();
+        if (helperUsage.calls > 0 && context.runtimeBus) {
+            emitOpsHelperUsage(context.runtimeBus, context.emitterContext(context.turnId), {
+                inputTokens: helperUsage.inputTokens,
+                outputTokens: helperUsage.outputTokens,
+                calls: helperUsage.calls,
+            });
+        }
+        const hitRateThreshold = context.configManager.get('cache.hitRateWarningThreshold');
+        if (cacheMetrics.turns >= 5
+            && cacheMetrics.hitRate < hitRateThreshold
+            && context.configManager.get('cache.monitorHitRate')) {
+            logger.info(`[Cache] Low hit rate: ${(cacheMetrics.hitRate * 100).toFixed(0)}% over ${cacheMetrics.turns} turns`);
+        }
+        context.setLastRequestInputTokens(response.usage.inputTokens);
+        context.setLastInputTokens(response.usage.inputTokens
+            + (response.usage.cacheReadTokens ?? 0)
+            + (response.usage.cacheWriteTokens ?? 0));
+        if (context.runtimeBus) {
+            emitLlmResponseReceived(context.runtimeBus, context.emitterContext(context.turnId), {
+                turnId: context.turnId,
+                provider: model.provider,
+                model: model.id,
+                content: response.content,
+                toolCallCount: response.toolCalls.length,
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                cacheReadTokens: response.usage.cacheReadTokens,
+                cacheWriteTokens: response.usage.cacheWriteTokens,
+            });
+        }
+        if (context.hookDispatcher) {
+            context.hookDispatcher.fire({
+                path: 'Post:llm:chat',
+                phase: 'Post',
+                category: 'llm',
+                specific: 'chat',
+                sessionId: context.sessionId,
+                timestamp: Date.now(),
+                payload: {
+                    model: model.id,
+                    provider: model.provider,
+                    inputTokens: response.usage.inputTokens,
+                    outputTokens: response.usage.outputTokens,
+                    toolCallCount: response.toolCalls.length,
+                },
+            }).catch(() => { });
+        }
+        const reasoningForMsg = reasoningAccumulated || undefined;
+        const reasoningSummaryForMsg = response.reasoningSummary || undefined;
+        if (response.stopReason === 'tool_use' && response.toolCalls.length === 0) {
+            emitMalformedToolUseWarning({
+                conversation: context.conversation,
+                providerRegistry: context.providerRegistry,
+                runtimeBus: context.runtimeBus,
+                emitterContext: (id) => context.emitterContext(id),
+                turnId: context.turnId,
+                isReconciliationEnabled: context.isReconciliationEnabled(),
+            });
+        }
+        if (response.toolCalls.length > 0) {
+            const enrichedResponse = {
+                ...response,
+                reasoning: reasoningForMsg,
+                reasoningSummary: reasoningSummaryForMsg,
+            };
+            const results = await handleToolResponseOutcome({
+                conversation: context.conversation,
+                agentManager: context.agentManager,
+                planManager: context.planManager,
+                configManager: context.configManager,
+                providerRegistry: context.providerRegistry,
+                runtimeBus: context.runtimeBus,
+                emitterContext: (id) => context.emitterContext(id),
+                turnId: context.turnId,
+                response: enrichedResponse,
+                executeToolCalls: (id, calls) => context.executeToolCalls(id, calls),
+                setPendingToolCalls: (calls) => { context.setPendingToolCalls(calls); },
+                messageQueueLength: context.getMessageQueueLength(),
+                requestRender: context.requestRender,
+                sessionId: context.sessionId,
+            });
+            const allFailed = results.results.length > 0 && results.results.every((result) => result.success === false);
+            if (allFailed) {
+                const breakerResult = circuitBreaker.recordAllFailed();
+                logger.warn(`Orchestrator: consecutive all-error turn ${circuitBreaker.consecutiveErrors}`);
+                if (breakerResult === 'break') {
+                    logger.warn(`Orchestrator: circuit breaker tripped at ${circuitBreaker.consecutiveErrors} consecutive all-error turns`);
+                    context.conversation.addSystemMessage(`CIRCUIT BREAKER: You have made ${circuitBreaker.consecutiveErrors} consecutive turns where ALL tool calls failed. `
+                        + `The loop is stopping to prevent an infinite failure cycle. `
+                        + `Please reassess your approach and try a completely different strategy.`);
+                    if (context.runtimeBus) {
+                        emitTurnError(context.runtimeBus, context.emitterContext(context.turnId), {
+                            turnId: context.turnId,
+                            error: 'Consecutive all-failed tool turns tripped the circuit breaker',
+                            stopReason: 'tool_loop_circuit_breaker',
+                        });
+                    }
+                    context.markTurnFailed();
+                    continueLoop = false;
+                }
+                else if (breakerResult === 'warn') {
+                    context.conversation.addSystemMessage(`WARNING: You have made ${circuitBreaker.consecutiveErrors} consecutive tool calls that ALL failed. `
+                        + `Stop attempting the same approach. Describe what you're trying to do and what's going wrong, `
+                        + `then try a completely different strategy.`);
+                }
+            }
+            else if (results.results.length > 0) {
+                circuitBreaker.recordSuccess();
+            }
+            continueLoop = results.continueLoop;
+            continue;
+        }
+        const enrichedResponse = {
+            ...response,
+            reasoning: reasoningForMsg,
+            reasoningSummary: reasoningSummaryForMsg,
+        };
+        continueLoop = handleFinalResponseOutcome({
+            conversation: context.conversation,
+            agentManager: context.agentManager,
+            planManager: context.planManager,
+            configManager: context.configManager,
+            providerRegistry: context.providerRegistry,
+            runtimeBus: context.runtimeBus,
+            emitterContext: (id) => context.emitterContext(id),
+            turnId: context.turnId,
+            response: enrichedResponse,
+            preTurnPlan: context.preTurnPlan,
+            requestRender: context.requestRender,
+            setAutoSpawnTimeout: (timeout) => { context.setAutoSpawnTimeout(timeout); },
+            autoSpawnTimeoutMs: AUTO_SPAWN_FALLBACK_DELAY_MS,
+            sessionId: context.sessionId,
+        });
+    }
+}

package/dist/_internal/platform/core/orchestrator.d.ts

@@ -0,0 +1,191 @@
+import type { ConversationManager } from './conversation.js';
+import type { ToolRegistry } from '../tools/registry.js';
+import type { HookEvent, HookResult } from '../hooks/types.js';
+import type { ContentPart } from '../providers/interface.js';
+import type { PermissionManager } from '../permissions/manager.js';
+import type { AcpManager } from '../acp/manager.js';
+import { type ConversationFollowUpItem } from './conversation-follow-ups.js';
+import { AgentManager } from '../tools/agent/index.js';
+import { WrfcController } from '../agents/wrfc-controller.js';
+import type { FeatureFlagManager } from '../runtime/feature-flags/manager.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import { type OrchestratorCoreServices } from './orchestrator-runtime.js';
+/** Minimal interface for hook dispatch — allows any compatible implementation */
+interface HookDispatcherLike {
+    fire(event: HookEvent): Promise<HookResult>;
+}
+interface LowPrioritySystemMessageSink {
+    low(message: string): void;
+}
+/**
+ * Orchestrator - Manages LLM turn lifecycle with full tool-use loop.
+ * Supports multi-turn agent loops: call LLM -> execute tools -> send results -> repeat.
+ */
+export declare class Orchestrator {
+    private conversation;
+    private getViewportHeight;
+    private scrollToEnd;
+    private toolRegistry;
+    private permissionManager;
+    private getSystemPrompt;
+    private hookDispatcher;
+    isThinking: boolean;
+    thinkingFrame: number;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    /**
+     * Input tokens from the most recent LLM response — represents current context window usage.
+     * Includes cache read/write tokens for accurate context window occupancy.
+     * Value is 0 before the first LLM response (context bar shows empty, which is correct).
+     */
+    lastInputTokens: number;
+    /** Fresh input tokens from the most recent turn (excluding cache-read reuse where applicable). */
+    lastRequestInputTokens: number;
+    /** Approximate input tokens for the current streaming turn (from prior turn's response). */
+    streamingInputTokens: number;
+    /** Output tokens received so far in the current streaming turn (one per delta chunk). */
+    streamingOutputTokens: number;
+    messageQueue: {
+        text: string;
+        content?: ContentPart[];
+    }[];
+    private animInterval;
+    private abortController;
+    private autoSpawnTimeout;
+    private acpManager;
+    /** Message count at the start of a turn, used to rollback on cancel. */
+    private turnStartMessageCount;
+    /** Whether a streaming block is currently active (for cleanup on abort). */
+    private isStreaming;
+    /** Last token warning bracket (multiples of 10%) to avoid repeat warnings at same level. */
+    private lastWarningBracket;
+    /** Whether auto-compaction is currently in progress (prevents re-entry). */
+    private isCompacting;
+    /** Session ID for hook events — unique per Orchestrator instance */
+    private readonly sessionId;
+    /**
+     * Submission key for the currently active turn.
+     *
+     * Generated at the start of each `runTurn` call and used as the idempotency
+     * key for the turn-level deduplication fence. A duplicate `runTurn` call with
+     * the same text that arrives while a turn is still in-flight will be detected
+     * via the shared `idempotencyStore` and rejected before re-executing.
+     *
+     * The key is reset to `null` when the turn completes.
+     */
+    currentSubmissionKey: string | null;
+    /**
+     * Tracks whether the current turn ended in failure.
+     * Set to `true` in the catch block; read in `finally` to decide markComplete vs markFailed.
+     */
+    private _turnFailed;
+    /** Event replay queue — ensures model acknowledges significant events */
+    private readonly replayQueue;
+    /** Cleanup function returned by the active replay queue attachment. */
+    private detachReplay;
+    private readonly runtimeBus;
+    private readonly agentManager;
+    private readonly wrfcController;
+    private coreServices;
+    private readonly ownedSessionLineageTracker;
+    private readonly ownedIdempotencyStore;
+    private readonly ownedCacheHitTracker;
+    /**
+     * Optional feature flag manager.
+     *
+     * When provided, the `tool-result-reconciliation` flag is
+     * consulted at each turn end to decide whether to use full reconciliation
+     * (`enabled`) or skip reconciliation (`disabled`).
+     * When `null`, reconciliation defaults to enabled (matching the flag's
+     * declared `defaultState`).
+     */
+    private flagManager;
+    /**
+     * Tracks the last provider response's tool calls within the current turn
+     * iteration so the reconciliation pass can detect unresolved calls when
+     * the loop exits early.
+     */
+    private _pendingToolCalls;
+    private readonly requestRender;
+    private systemMessageRouter;
+    private readonly followUpRuntime;
+    constructor(conversation: ConversationManager, getViewportHeight: () => number, scrollToEnd: (vHeight: number) => void, toolRegistry: ToolRegistry, permissionManager: PermissionManager, getSystemPrompt: (() => string) | undefined, hookDispatcher: (HookDispatcherLike | null) | undefined, flagManager: (FeatureFlagManager | null) | undefined, requestRender: (() => void) | null | undefined, runtimeBus: (RuntimeEventBus | null) | undefined, services: {
+        readonly agentManager: Pick<AgentManager, 'list' | 'spawn'>;
+        readonly wrfcController: Pick<WrfcController, 'listChains'>;
+    });
+    setCoreServices(services: OrchestratorCoreServices): void;
+    /**
+     * Attach an AcpManager and register the 'delegate' tool into the ToolRegistry.
+     * Call this after construction, before the first turn.
+     */
+    registerDelegateTool(manager: AcpManager): void;
+    getSpinner(): string;
+    setSystemMessageRouter(router: LowPrioritySystemMessageSink | null): void;
+    enqueueConversationFollowUp(item: ConversationFollowUpItem): void;
+    /** Abort the current in-flight LLM request, if any. */
+    abort(): void;
+    /**
+     * Dispose long-lived runtime attachments owned by this orchestrator.
+     *
+     * Safe to call multiple times. Intended for process shutdown and tests that
+     * construct transient orchestrators against a shared RuntimeEventBus.
+     */
+    dispose(): void;
+    /**
+     * handleUserInput - Entry point for a user-submitted message.
+     * Queues if already thinking, otherwise kicks off the LLM turn.
+     * @param text - Plain text representation (for display and queuing).
+     * @param content - Optional ContentPart[] for multimodal messages.
+     */
+    handleUserInput(text: string, content?: ContentPart[]): Promise<void>;
+    private startThinking;
+    private stopThinking;
+    private runTurn;
+    /**
+     * Pre-flight context window check.
+     *
+     * Estimates the token count of the pending request and compares it against
+     * the model's context window from the catalog. If the request exceeds the
+     * context window:
+     *   1. If auto-compact is enabled (threshold configured), compact first.
+     *   2. If still exceeds after compact, emit a clear error message with
+     *      specific token counts and suggest alternatives.
+     *
+     * @returns 'ok' (within context), 'compacted' (compacted and now OK), or
+     *          'error' (still exceeds even after compact, or compact disabled).
+     */
+    private checkContextWindowPreflight;
+    /**
+     * Auto-spawn agents for a list of ready plan items under bounded orchestration policy.
+     */
+    private autoSpawnPendingItems;
+    /**
+     * Returns `true` when the GC-ORCH-015 reconciliation feature is active.
+     *
+     * Defaults to `true` (flag `defaultState: 'enabled'`) when no flag manager
+     * has been wired in — safe for tests that omit the optional constructor arg.
+     */
+    private isReconciliationEnabled;
+    /**
+     * Reconcile unresolved tool calls at turn end.
+     *
+     * Called when the turn loop exits while `_pendingToolCalls` is non-empty,
+     * or when a malformed provider response is detected. Injects synthetic error
+     * results for every unresolved call, adds a system message, and emits a
+     * typed `TOOL_RECONCILED` runtime event.
+     *
+     * When the feature flag is disabled this method logs a warning and returns
+     * without taking action.
+     *
+     * @param resolvedResults - Tool results already collected this iteration.
+     * @param reason          - Why reconciliation was triggered.
+     */
+    private reconcileUnresolvedToolCalls;
+    private executeToolCalls;
+}
+export {};
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/_internal/platform/core/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/core/orchestrator.ts"],"names":[],"mappings":"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"}