@nervekit/orchestrator 0.1.0

package/dist/agent-runner/agent-runner.js

@@ -0,0 +1,802 @@
+import { AgentHarness, AgentToolSuspension, buildConversationContext, Conversation, computeContextUsage, convertToLlm, estimateContextTokens, getModelContextWindow, isAgentToolSuspension, NodeExecutionEnv, resolveAgentModel, shouldCompact, } from "@nerve/agent";
+import { createId, toolNameSchema, } from "@nerve/shared";
+import { activeToolNamesForAgent, createAgentToolsForAgent, toolPromptMetadata, } from "../domains/tools/agent-tool-adapter.js";
+import { HttpError } from "../http/errors.js";
+import { planDirForStorageHome } from "../domains/plans/plan-paths.js";
+import { loadHarnessResources } from "../resource-loader.js";
+import { SubagentRunner } from "./subagent-runner.js";
+import { composeAgentSystemPrompt } from "./system-prompt-builder.js";
+import { shouldStreamToolDraftArguments } from "./tool-draft-streaming.js";
+export class AgentRunner {
+    deps;
+    subagents;
+    constructor(deps) {
+        this.deps = deps;
+        this.subagents = new SubagentRunner({
+            storage: deps.storage,
+            events: deps.events,
+            harnessManager: deps.harnessManager,
+            createAgent: deps.createAgent,
+            runAgentPrompt: (agent, request) => this.runAgentPrompt(agent, request),
+            appendEntry: deps.appendEntry,
+            getConversation: deps.getConversation,
+            updateConversation: deps.updateConversation,
+        });
+    }
+    async promptAgent(agentId, request) {
+        const agent = this.deps.agents.get(agentId);
+        if (!agent)
+            throw new HttpError(404, "AGENT_NOT_FOUND", "Agent not found.");
+        if (agent.status === "awaiting_user") {
+            throw new HttpError(409, "AGENT_AWAITING_USER", "Agent is awaiting a human-in-the-loop tool response.");
+        }
+        const activeRun = this.deps.runs.get(agent.id);
+        if (activeRun) {
+            const behavior = request.behavior ?? "steer";
+            if (behavior === "reject-if-busy") {
+                throw new HttpError(409, "AGENT_BUSY", "Agent is already running.");
+            }
+            const callback = behavior === "follow-up" ? activeRun.followUp : activeRun.steer;
+            if (!callback) {
+                throw new HttpError(409, "AGENT_BUSY", "Agent is already running.");
+            }
+            const queuedPrompt = await this.deps.promptQueue.enqueue({
+                agentId: agent.id,
+                conversationId: agent.conversationId,
+                projectId: agent.projectId,
+                runId: activeRun.runId,
+                behavior,
+                text: request.text,
+                images: request.images,
+            });
+            this.deps.conversationRuntime.queuePrompt(activeRun.runId, queuedPrompt);
+            await this.deps.events.publish("conversation.prompt.queued", {
+                conversationId: agent.conversationId,
+                agentId: agent.id,
+                projectId: agent.projectId,
+                runId: activeRun.runId,
+                queuedPrompt,
+            });
+            try {
+                await callback(request.text, request, queuedPrompt.id);
+                const accepted = await this.deps.promptQueue.markAccepted(queuedPrompt.id, agent.id, activeRun.runId);
+                if (accepted)
+                    this.deps.conversationRuntime.queuePrompt(activeRun.runId, accepted);
+            }
+            catch (error) {
+                await this.deps.promptQueue.markFailed(queuedPrompt.id, agent.id, error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+            return;
+        }
+        void this.runAgentPrompt(agent, request).catch(() => undefined);
+    }
+    async continueAgent(agentId) {
+        const agent = this.deps.agents.get(agentId);
+        if (!agent)
+            throw new HttpError(404, "AGENT_NOT_FOUND", "Agent not found.");
+        if (this.deps.runs.has(agent.id)) {
+            throw new HttpError(409, "AGENT_BUSY", "Agent is already running.");
+        }
+        void this.runAgentPrompt(agent, { text: "Continue after resolved tool result." }, { continue: true }).catch(() => undefined);
+    }
+    async continueFromFailedTurn(agentId, failedEntryId) {
+        const agent = this.deps.agents.get(agentId);
+        if (!agent)
+            throw new HttpError(404, "AGENT_NOT_FOUND", "Agent not found.");
+        if (this.deps.runs.has(agent.id)) {
+            throw new HttpError(409, "AGENT_BUSY", "Agent is already running.");
+        }
+        const conversation = this.deps.getConversation(agent.conversationId);
+        const project = this.deps.getProject(agent.projectId);
+        const storage = await this.deps.harnessManager.openStorage(conversation, project.dir);
+        const failedEntry = await storage.getEntry(failedEntryId);
+        const failedMessage = failedEntry?.type === "message" ? failedEntry.message : undefined;
+        if (!failedEntry ||
+            failedEntry.type !== "message" ||
+            failedMessage?.role !== "assistant" ||
+            failedMessage.stopReason !== "error" ||
+            failedEntry.parentId === null) {
+            throw new HttpError(400, "INVALID_FAILED_ENTRY", "Failed entry is not a retryable assistant failure.");
+        }
+        await new Conversation(storage).moveTo(failedEntry.parentId);
+        void this.runAgentPrompt(agent, { text: "Continue from failed model request." }, { continue: true }).catch(() => undefined);
+    }
+    async abortAgent(agentId) {
+        const agent = this.deps.agents.get(agentId);
+        if (!agent)
+            throw new HttpError(404, "AGENT_NOT_FOUND", "Agent not found.");
+        for (const child of this.deps.agents.values()) {
+            if (child.parentAgentId === agent.id)
+                await this.abortAgent(child.id);
+        }
+        const run = this.deps.runs.get(agentId);
+        if (!run)
+            return;
+        run.abort();
+        await this.deps.events.publish("agent.abort_requested", {
+            agentId,
+            runId: run.runId,
+        });
+    }
+    runSubagent(parent, args) {
+        return this.subagents.runSubagent(parent, args);
+    }
+    async runAgentPrompt(agent, request, options = {}) {
+        if (this.deps.runs.has(agent.id)) {
+            throw new HttpError(409, "AGENT_BUSY", "Agent is already running.");
+        }
+        const runId = createId("run");
+        const runStartedAt = performance.now();
+        let abortRequested = false;
+        let lastAssistantEntry;
+        let currentTurnId;
+        let currentLiveMessageId;
+        const liveToolDraftNames = new Map();
+        const pendingProviderToolCalls = new Map();
+        try {
+            await this.deps.logger.info("Agent run preparing", {
+                agentId: agent.id,
+                conversationId: agent.conversationId,
+                projectId: agent.projectId,
+                runId,
+                context: { behavior: request.behavior, continue: options.continue },
+            });
+            const conversation = this.deps.getConversation(agent.conversationId);
+            const project = this.deps.getProject(agent.projectId);
+            const storage = await this.deps.harnessManager.openStorage(conversation, project.dir);
+            const harnessConversation = new Conversation(storage);
+            const initialHarnessEntryIds = new Set((await storage.getEntries()).map((entry) => entry.id));
+            const activeToolNames = activeToolNamesForAgent(agent);
+            const model = resolveAgentModel(agent.model);
+            this.deps.subscriptionUsage.touchProvider(model.provider);
+            const env = new NodeExecutionEnv({ cwd: agent.projectDir });
+            const resources = await loadHarnessResources(agent.projectDir);
+            const latestAgent = () => this.deps.agents.get(agent.id) ?? agent;
+            const composeLatestSystemPrompt = () => {
+                const currentAgent = latestAgent();
+                const currentActiveToolNames = activeToolNamesForAgent(currentAgent);
+                return composeAgentSystemPrompt(currentAgent, currentActiveToolNames, toolPromptMetadata(currentActiveToolNames), resources, { planDir: planDirForStorageHome(this.deps.storage.paths.home) });
+            };
+            const harness = new AgentHarness({
+                env,
+                conversation: harnessConversation,
+                resources: { skills: resources.skills },
+                tools: createAgentToolsForAgent(agent, this.deps.tools, {
+                    runId,
+                    resolveToolAnchor: (providerToolCallId) => this.deps.conversationRuntime.resolveToolAnchor(runId, providerToolCallId),
+                }),
+                activeToolNames,
+                model,
+                thinkingLevel: agent.thinkingLevel,
+                getApiKeyAndHeaders: async (requestModel) => {
+                    if (requestModel.provider === "nerve-faux")
+                        return undefined;
+                    const apiKey = await this.deps.auth.getApiKey(requestModel.provider);
+                    return apiKey ? { apiKey } : undefined;
+                },
+                systemPrompt: composeLatestSystemPrompt,
+            });
+            harness.subscribe(async (event) => {
+                if (event.type === "after_provider_response") {
+                    if (model.provider === "openai-codex") {
+                        this.deps.subscriptionUsage.applyCodexHeaders(event.headers);
+                    }
+                    return;
+                }
+                if (event.type === "turn_start") {
+                    const turn = this.deps.conversationRuntime.startTurn(runId);
+                    currentTurnId = turn.turnId;
+                    currentLiveMessageId = undefined;
+                    pendingProviderToolCalls.clear();
+                    return;
+                }
+                if (event.type === "tool_execution_start") {
+                    pendingProviderToolCalls.set(event.toolCallId, {
+                        toolName: event.toolName,
+                        args: recordFromUnknown(event.args),
+                    });
+                    return;
+                }
+                if (event.type === "tool_execution_end") {
+                    const started = pendingProviderToolCalls.get(event.toolCallId);
+                    pendingProviderToolCalls.delete(event.toolCallId);
+                    if (!event.isError)
+                        return;
+                    if (this.deps.tools.findToolCallByProviderToolCallId(event.toolCallId)) {
+                        return;
+                    }
+                    const parsedToolName = toolNameSchema.safeParse(event.toolName);
+                    if (!parsedToolName.success) {
+                        await this.deps.logger.warn("Unknown tool call failed before execution", {
+                            agentId: agent.id,
+                            conversationId: agent.conversationId,
+                            projectId: agent.projectId,
+                            runId,
+                            context: {
+                                toolName: event.toolName,
+                                providerToolCallId: event.toolCallId,
+                            },
+                        });
+                        return;
+                    }
+                    await this.deps.tools.recordProviderToolCallError(agent, parsedToolName.data, started?.args ?? {}, errorTextFromToolResult(event.result, event.toolName), {
+                        sourceToolCallId: event.toolCallId,
+                        providerToolCallId: event.toolCallId,
+                        runId,
+                        anchor: this.deps.conversationRuntime.resolveToolAnchor(runId, event.toolCallId),
+                    });
+                    return;
+                }
+                if (event.type === "message_start" &&
+                    event.message.role === "assistant") {
+                    if (!currentTurnId) {
+                        const turn = this.deps.conversationRuntime.startTurn(runId);
+                        currentTurnId = turn.turnId;
+                    }
+                    const started = this.deps.conversationRuntime.startAssistantMessage(runId, currentTurnId);
+                    currentLiveMessageId = started.liveMessageId;
+                    liveToolDraftNames.clear();
+                    await this.deps.events.publish("conversation.live.message.started", started, { durability: "transient" });
+                    return;
+                }
+                if (event.type === "message_update") {
+                    if (!currentTurnId || !currentLiveMessageId)
+                        return;
+                    const update = event.assistantMessageEvent;
+                    if (update.type === "text_delta") {
+                        const data = this.deps.conversationRuntime.applyContentDelta({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            kind: "text",
+                            delta: update.delta,
+                        });
+                        await this.deps.events.publish("conversation.live.content.delta", data, { durability: "transient" });
+                    }
+                    else if (update.type === "thinking_delta") {
+                        const data = this.deps.conversationRuntime.applyContentDelta({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            kind: "thinking",
+                            delta: update.delta,
+                        });
+                        await this.deps.events.publish("conversation.live.content.delta", data, { durability: "transient" });
+                    }
+                    else if (update.type === "text_end") {
+                        const data = this.deps.conversationRuntime.finishContent({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            kind: "text",
+                            finalText: update.content,
+                        });
+                        await this.deps.events.publish("conversation.live.content.done", data, {
+                            durability: "transient",
+                        });
+                    }
+                    else if (update.type === "thinking_end") {
+                        const data = this.deps.conversationRuntime.finishContent({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            kind: "thinking",
+                            finalText: update.content,
+                            redacted: assistantContentRedacted(update.partial, update.contentIndex),
+                        });
+                        await this.deps.events.publish("conversation.live.content.done", data, {
+                            durability: "transient",
+                        });
+                    }
+                    else if (update.type === "toolcall_start") {
+                        const draft = assistantToolCallDraft(update.partial, update.contentIndex);
+                        liveToolDraftNames.set(update.contentIndex, draft?.name);
+                        const data = this.deps.conversationRuntime.startToolDraft({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            providerToolCallId: draft?.id,
+                            toolName: draft?.name,
+                        });
+                        await this.deps.events.publish("conversation.live.tool_draft.started", data, { durability: "transient" });
+                    }
+                    else if (update.type === "toolcall_delta") {
+                        const draft = assistantToolCallDraft(update.partial, update.contentIndex);
+                        const toolName = draft?.name ?? liveToolDraftNames.get(update.contentIndex);
+                        if (draft?.name)
+                            liveToolDraftNames.set(update.contentIndex, draft.name);
+                        if (!shouldStreamToolDraftArguments(toolName))
+                            return;
+                        const data = this.deps.conversationRuntime.applyToolDraftDelta({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            delta: update.delta,
+                        });
+                        await this.deps.events.publish("conversation.live.tool_draft.delta", data, { durability: "transient" });
+                    }
+                    else if (update.type === "toolcall_end") {
+                        liveToolDraftNames.delete(update.contentIndex);
+                        const data = this.deps.conversationRuntime.finishToolDraft({
+                            runId,
+                            turnId: currentTurnId,
+                            liveMessageId: currentLiveMessageId,
+                            contentIndex: update.contentIndex,
+                            providerToolCallId: update.toolCall.id,
+                            toolName: update.toolCall.name,
+                            args: update.toolCall.arguments,
+                        });
+                        await this.deps.events.publish("conversation.live.tool_draft.done", data, { durability: "transient" });
+                    }
+                    return;
+                }
+                if (event.type === "message_end") {
+                    const liveMessageId = event.message.role === "assistant"
+                        ? currentLiveMessageId
+                        : undefined;
+                    const mirrored = await this.deps.messageMirror.mirrorNewHarnessEntries(agent, storage, initialHarnessEntryIds, {
+                        runId,
+                        turnId: currentTurnId,
+                        liveMessageId,
+                    });
+                    let shouldPublishContextUsage = false;
+                    for (const entry of mirrored) {
+                        await this.deps.events.publish("conversation.entry.appended", {
+                            conversationId: agent.conversationId,
+                            agentId: agent.id,
+                            runId,
+                            turnId: entry.turnId ?? currentTurnId,
+                            liveMessageId: entry.liveMessageId,
+                            entry,
+                        });
+                        if (entry.role === "user") {
+                            await this.maybeMarkQueuedPromptDelivered(agent, runId, entry);
+                            await this.deps.messageMirror.maybeDeriveInitialConversationTitle(conversation.id, entry.text);
+                        }
+                        else if (entry.role === "assistant") {
+                            lastAssistantEntry = entry;
+                            if (entry.usage)
+                                shouldPublishContextUsage = true;
+                        }
+                    }
+                    if (shouldPublishContextUsage) {
+                        await this.publishContextUsage(agent.conversationId, agent.id, runId).catch((error) => {
+                            process.emitWarning(`Context-usage publish failed for ${agent.conversationId}: ${error instanceof Error ? error.message : String(error)}`);
+                        });
+                    }
+                    if (event.message.role === "assistant")
+                        currentLiveMessageId = undefined;
+                    return;
+                }
+            });
+            const startedAt = new Date().toISOString();
+            this.deps.conversationRuntime.startRun({
+                agentId: agent.id,
+                projectId: agent.projectId,
+                conversationId: agent.conversationId,
+                runId,
+                startedAt,
+            });
+            await this.deps.events.publish("conversation.run.started", {
+                agentId: agent.id,
+                projectId: agent.projectId,
+                conversationId: agent.conversationId,
+                runId,
+                parentEntryId: conversation.activeEntryId,
+                startedAt,
+            });
+            await this.deps.logger.info("Agent run started", {
+                agentId: agent.id,
+                conversationId: agent.conversationId,
+                projectId: agent.projectId,
+                runId,
+                context: {
+                    parentEntryId: conversation.activeEntryId,
+                    model: model.id,
+                    provider: model.provider,
+                },
+            });
+            this.deps.runs.set(agent.id, {
+                runId,
+                abort: () => {
+                    abortRequested = true;
+                    this.deps.conversationRuntime.markAborting(runId);
+                    void harness.abort();
+                },
+                messages: this.deps.conversationService.getForAgent(agent.id) ?? [],
+                steer: (text, options) => harness.steer(text, { images: options?.images }),
+                followUp: (text, options) => harness.followUp(text, { images: options?.images }),
+                updateAgentRuntimeConfig: async (updatedAgent) => {
+                    await harness.setActiveTools(activeToolNamesForAgent(updatedAgent));
+                },
+            });
+            await this.deps.setAgentStatus(agent, "running");
+            const runAssistant = await this.runHarnessWithRetries({
+                harness,
+                conversation: harnessConversation,
+                request,
+                continue: options.continue === true,
+                runId,
+                agent,
+            });
+            const latest = this.deps.agents.get(agent.id);
+            this.deps.runs.delete(agent.id);
+            const branch = await storage.getPathToRoot(await storage.getLeafId());
+            const messages = convertToLlm(buildConversationContext(branch).messages);
+            this.deps.conversationService.setForAgent(agent.id, messages);
+            const assistantEntry = lastAssistantEntry;
+            if (!assistantEntry) {
+                throw new Error("Agent run completed without an assistant entry.");
+            }
+            if (runAssistant.stopReason === "error" ||
+                runAssistant.stopReason === "aborted") {
+                const aborted = runAssistant.stopReason === "aborted" || abortRequested;
+                if (latest)
+                    await this.deps.setAgentStatus(latest, aborted ? "aborted" : "error");
+                if (!aborted) {
+                    await this.maybeAppendRetryExhaustedStatus(agent, runId, assistantEntry, runAssistant);
+                }
+                await this.deps.events.publish("conversation.run.failed", {
+                    agentId: agent.id,
+                    projectId: agent.projectId,
+                    runId,
+                    conversationId: agent.conversationId,
+                    message: runAssistant.errorMessage ?? "Agent run failed.",
+                    aborted,
+                    failedAt: new Date().toISOString(),
+                });
+                await this.deps.logger.warn("Agent run failed", {
+                    agentId: agent.id,
+                    conversationId: agent.conversationId,
+                    projectId: agent.projectId,
+                    runId,
+                    durationMs: Math.round(performance.now() - runStartedAt),
+                    context: {
+                        finalEntryId: assistantEntry.id,
+                        stopReason: runAssistant.stopReason,
+                        errorMessage: runAssistant.errorMessage,
+                    },
+                });
+                this.deps.conversationRuntime.failRun(runId);
+                return assistantEntry;
+            }
+            if (latest)
+                await this.deps.setAgentStatus(latest, "idle");
+            const completedAt = new Date().toISOString();
+            await this.deps.events.publish("conversation.run.completed", {
+                agentId: agent.id,
+                projectId: agent.projectId,
+                runId,
+                conversationId: agent.conversationId,
+                finalEntryId: assistantEntry.id,
+                completedAt,
+            });
+            await this.deps.logger.info("Agent run completed", {
+                agentId: agent.id,
+                conversationId: agent.conversationId,
+                projectId: agent.projectId,
+                runId,
+                durationMs: Math.round(performance.now() - runStartedAt),
+                context: { finalEntryId: assistantEntry.id },
+            });
+            this.deps.conversationRuntime.completeRun(runId);
+            await this.maybeAutoCompact(agent.conversationId).catch((error) => {
+                process.emitWarning(`Auto-compaction failed for ${agent.conversationId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            await this.publishContextUsage(agent.conversationId, agent.id, runId).catch((error) => {
+                process.emitWarning(`Context-usage publish failed for ${agent.conversationId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            return assistantEntry;
+        }
+        catch (error) {
+            const suspensionError = isAgentToolSuspension(error)
+                ? error
+                : this.suspensionFromWaitingToolCall(agent, runId, error);
+            if (suspensionError) {
+                this.deps.runs.delete(agent.id);
+                const latest = this.deps.agents.get(agent.id);
+                const toolCall = this.deps.tools.getToolCall(suspensionError.data.toolCallId);
+                const providerToolCallId = toolCall.providerToolCallId ??
+                    toolCall.sourceToolCallId ??
+                    suspensionError.data.toolCall?.id ??
+                    suspensionError.data.toolCallId;
+                const suspension = await this.deps.suspensions.createSuspension({
+                    agentId: agent.id,
+                    conversationId: agent.conversationId,
+                    projectId: agent.projectId,
+                    runId,
+                    turnId: currentTurnId,
+                    liveMessageId: currentLiveMessageId,
+                    assistantEntryId: lastAssistantEntry?.id,
+                    toolCallId: toolCall.id,
+                    providerToolCallId,
+                    toolName: toolCall.toolName,
+                    remainingToolCalls: (suspensionError.data.remainingToolCalls ?? []).map((remaining) => ({
+                        id: remaining.id,
+                        name: remaining.name,
+                        arguments: remaining.arguments,
+                    })),
+                    reason: suspensionError.data.reason,
+                });
+                if (latest)
+                    await this.deps.setAgentStatus(latest, "awaiting_user");
+                const suspendedAt = new Date().toISOString();
+                await this.deps.events.publish("conversation.run.suspended", {
+                    agentId: agent.id,
+                    projectId: agent.projectId,
+                    runId,
+                    conversationId: agent.conversationId,
+                    suspensionId: suspension.id,
+                    toolCallId: toolCall.id,
+                    suspendedAt,
+                    reason: suspensionError.data.reason,
+                });
+                await this.deps.logger.info("Agent run suspended", {
+                    agentId: agent.id,
+                    conversationId: agent.conversationId,
+                    projectId: agent.projectId,
+                    runId,
+                    toolCallId: toolCall.id,
+                    durationMs: Math.round(performance.now() - runStartedAt),
+                    context: {
+                        suspensionId: suspension.id,
+                        reason: suspensionError.data.reason,
+                    },
+                });
+                this.deps.conversationRuntime.completeRun(runId);
+                if (lastAssistantEntry)
+                    return lastAssistantEntry;
+                throw new Error("Agent run suspended without an assistant entry.");
+            }
+            this.deps.runs.delete(agent.id);
+            const aborted = abortRequested;
+            const latest = this.deps.agents.get(agent.id);
+            if (latest)
+                await this.deps.setAgentStatus(latest, aborted ? "aborted" : "error");
+            await this.deps.events.publish("conversation.run.failed", {
+                agentId: agent.id,
+                projectId: agent.projectId,
+                runId,
+                conversationId: agent.conversationId,
+                message: error instanceof Error ? error.message : String(error),
+                aborted,
+                failedAt: new Date().toISOString(),
+            });
+            await this.deps.logger[aborted ? "warn" : "error"](aborted ? "Agent run aborted" : "Agent run failed", {
+                agentId: agent.id,
+                conversationId: agent.conversationId,
+                projectId: agent.projectId,
+                runId,
+                durationMs: Math.round(performance.now() - runStartedAt),
+                context: { aborted },
+                error,
+            });
+            this.deps.conversationRuntime.failRun(runId);
+            throw error;
+        }
+    }
+    async maybeAppendRetryExhaustedStatus(agent, runId, assistantEntry, assistant) {
+        const settings = this.deps.storage.settings.retry;
+        if (!settings.enabled ||
+            settings.maxRetries <= 0 ||
+            !isRetryableAssistantError(assistant)) {
+            return;
+        }
+        const details = {
+            type: "agent_run_retry_status",
+            state: "retry_exhausted",
+            runId,
+            failedEntryId: assistantEntry.id,
+            attempt: settings.maxRetries,
+            maxRetries: settings.maxRetries,
+            errorMessage: assistant.errorMessage,
+            retryable: true,
+        };
+        const statusEntry = await this.deps.appendEntry({
+            conversationId: agent.conversationId,
+            agentId: agent.id,
+            runId,
+            parentEntryId: assistantEntry.id,
+            role: "system",
+            kind: "run_status",
+            text: `Model request failed after ${settings.maxRetries} ${settings.maxRetries === 1 ? "retry" : "retries"}.`,
+            details,
+        }, { mirrorToHarness: false });
+        await this.deps.events.publish("conversation.entry.appended", {
+            conversationId: agent.conversationId,
+            agentId: agent.id,
+            projectId: agent.projectId,
+            runId,
+            entry: statusEntry,
+        });
+    }
+    async runHarnessWithRetries(input) {
+        const settings = this.deps.storage.settings.retry;
+        let attempt = 0;
+        let continueRun = input.continue;
+        while (true) {
+            const assistant = continueRun
+                ? await input.harness.continue()
+                : await input.harness.prompt(input.request.text, {
+                    images: input.request.images,
+                });
+            if (assistant.stopReason !== "error" ||
+                !isRetryableAssistantError(assistant) ||
+                !settings.enabled ||
+                attempt >= settings.maxRetries) {
+                return assistant;
+            }
+            attempt += 1;
+            const delayMs = settings.baseDelayMs * 2 ** (attempt - 1);
+            const retryAt = new Date(Date.now() + delayMs).toISOString();
+            const leafId = await input.conversation.getLeafId();
+            const leaf = leafId
+                ? await input.conversation.getEntry(leafId)
+                : undefined;
+            const failedEntryId = leaf?.type === "message" ? leaf.id : undefined;
+            const retry = {
+                attempt,
+                maxRetries: settings.maxRetries,
+                delayMs,
+                retryAt,
+                errorMessage: assistant.errorMessage,
+                failedEntryId,
+            };
+            this.deps.conversationRuntime.markRetrying(input.runId, retry);
+            await this.deps.events.publish("conversation.run.retrying", {
+                agentId: input.agent.id,
+                conversationId: input.agent.conversationId,
+                projectId: input.agent.projectId,
+                runId: input.runId,
+                ...retry,
+            });
+            await this.deps.logger.warn("Retrying transient agent error", {
+                agentId: input.agent.id,
+                conversationId: input.agent.conversationId,
+                projectId: input.agent.projectId,
+                runId: input.runId,
+                context: {
+                    attempt,
+                    maxRetries: settings.maxRetries,
+                    errorMessage: assistant.errorMessage,
+                },
+            });
+            if (leaf?.parentId !== undefined)
+                await input.conversation.moveTo(leaf.parentId);
+            await delay(delayMs);
+            this.deps.conversationRuntime.clearRetry(input.runId);
+            continueRun = true;
+        }
+    }
+    async maybeMarkQueuedPromptDelivered(agent, runId, entry) {
+        const queuedPrompt = (await this.deps.promptQueue.pendingForAgent(agent.id))
+            .filter((candidate) => candidate.runId === runId &&
+            (candidate.status === "accepted" || candidate.status === "queued") &&
+            candidate.text === entry.text)
+            .at(0);
+        if (!queuedPrompt)
+            return;
+        const delivered = await this.deps.promptQueue.markDelivered(queuedPrompt.id, agent.id, entry.id);
+        if (!delivered)
+            return;
+        this.deps.conversationRuntime.removeQueuedPrompt(runId, delivered.id);
+        await this.deps.events.publish("conversation.prompt.dequeued", {
+            conversationId: agent.conversationId,
+            agentId: agent.id,
+            projectId: agent.projectId,
+            runId,
+            queuedPrompt: delivered,
+            entryId: entry.id,
+        });
+    }
+    suspensionFromWaitingToolCall(agent, runId, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const toolCall = this.deps.tools
+            .listToolCalls()
+            .find((candidate) => candidate.agentId === agent.id &&
+            candidate.runId === runId &&
+            candidate.status === "waiting_for_user" &&
+            (candidate.toolName === "ask_user" ||
+                candidate.toolName === "plan_mode_present"));
+        if (!toolCall)
+            return undefined;
+        return new AgentToolSuspension({
+            toolCallId: toolCall.id,
+            toolName: toolCall.toolName,
+            reason: message || `Tool ${toolCall.toolName} is awaiting user input.`,
+            remainingToolCalls: [],
+        });
+    }
+    /** Compute compaction-aware context-window usage for a conversation. */
+    async getContextUsage(conversationId) {
+        const conversation = this.deps.getConversation(conversationId);
+        const project = this.deps.getProject(conversation.projectId);
+        const storage = await this.deps.harnessManager.openStorage(conversation, project.dir);
+        const branch = await storage.getPathToRoot(await storage.getLeafId());
+        const messages = buildConversationContext(branch).messages;
+        const agent = conversation.activeAgentId
+            ? this.deps.agents.get(conversation.activeAgentId)
+            : undefined;
+        const contextWindow = getModelContextWindow(agent?.model);
+        return computeContextUsage(messages, branch, contextWindow);
+    }
+    async publishContextUsage(conversationId, agentId, runId) {
+        const contextUsage = await this.getContextUsage(conversationId);
+        await this.deps.events.publish("conversation.context.updated", { conversationId, agentId, runId, contextUsage }, { durability: "transient" });
+    }
+    async maybeAutoCompact(conversationId) {
+        if (!this.deps.storage.settings.compaction.auto)
+            return;
+        const conversation = this.deps.getConversation(conversationId);
+        const project = this.deps.getProject(conversation.projectId);
+        const storage = await this.deps.harnessManager.openStorage(conversation, project.dir);
+        const branch = await storage.getPathToRoot(await storage.getLeafId());
+        const tokens = estimateContextTokens(buildConversationContext(branch).messages).tokens;
+        const agent = conversation.activeAgentId
+            ? this.deps.agents.get(conversation.activeAgentId)
+            : undefined;
+        const contextWindow = getModelContextWindow(agent?.model);
+        if (contextWindow <= 0)
+            return;
+        const settings = {
+            enabled: this.deps.storage.settings.compaction.auto,
+            reserveTokens: this.deps.storage.settings.compaction.reserveTokens,
+            keepRecentTokens: this.deps.storage.settings.compaction.keepRecentTokens,
+        };
+        if (!shouldCompact(tokens, contextWindow, settings))
+            return;
+        await this.deps.compactionService.compactConversation(conversationId, {
+            instructions: "Automatic compaction after the selected model's context threshold was exceeded.",
+            keepRecentTokens: settings.keepRecentTokens,
+        });
+    }
+}
+function recordFromUnknown(value) {
+    return value && typeof value === "object"
+        ? value
+        : {};
+}
+function errorTextFromToolResult(result, toolName) {
+    const record = recordFromUnknown(result);
+    const content = Array.isArray(record.content) ? record.content : [];
+    const text = content
+        .map((part) => {
+        const partRecord = recordFromUnknown(part);
+        return partRecord.type === "text" && typeof partRecord.text === "string"
+            ? partRecord.text
+            : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+    return text.trim() || `Tool ${toolName} failed before execution.`;
+}
+function isRetryableAssistantError(message) {
+    if (message.stopReason !== "error" || !message.errorMessage)
+        return false;
+    const error = message.errorMessage;
+    if (/GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing|context.?length|context.?window|maximum context|too many tokens/i.test(error)) {
+        return false;
+    }
+    return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i.test(error);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function assistantContentRedacted(message, contentIndex) {
+    const block = message.content[contentIndex];
+    return block?.type === "thinking" ? block.redacted : undefined;
+}
+function assistantToolCallDraft(message, contentIndex) {
+    const block = message.content[contentIndex];
+    return block?.type === "toolCall"
+        ? { id: block.id, name: block.name }
+        : undefined;
+}
+//# sourceMappingURL=agent-runner.js.map