@auvira.ai/sdk 0.4.0 → 0.6.0

package/dist/providers/agentic/agentLoop.js

@@ -2,7 +2,8 @@ import { buildAssistantEvent } from "../../agent/assistantEvent.js";
 import { throwIfCancelled } from "../../agent/cancellation.js";
 import { emitAgentCompletionCheckThinking, emitAgentPlanningThinking, emitAgentRawModelTrace, emitAgentReflectionThinking, emitAgentToolSelectionThinking, } from "../../agent/emitAgentThinking.js";
 import { buildIncompleteContinuationNudge, computeCompletionEvaluationKey, evaluateTaskCompletion, getCompletionMaxContinues, getTaskCompletionConfidenceThreshold, } from "../../agent/evaluateTaskCompletion.js";
-import { evaluateHarnessCompletionGate, getWiringIncompleteNudge, isStyleOnlyDiff, } from "../../agent/editCompletion.js";
+import { evaluateHarnessCompletionGate, getAssetPublishIncompleteNudge, getCompletionRulesIncompleteNudge, getWiringIncompleteNudge, isStyleOnlyDiff, } from "../../agent/editCompletion.js";
+import { clearHostToolsForRun, hostToolsToOpenAiDefinitions, registerHostToolsForRun, resolveHostToolsForRun, } from "../../agent/hostTools.js";
 import { executeAgentTool, parseToolArguments, } from "../../agent/tools/executeTool.js";
 import { filterAllowlistedChangedFiles, } from "../../agent/tools/pathGuard.js";
 import { gitDiff } from "../../git/gitDiff.js";
@@ -12,7 +13,7 @@ import { formatRateLimitReport, formatTimingReport, postJsonWithRetry, } from ".
 import { applyCustomModelRequestDefaults, bumpMaxCompletionTokensForLengthRetry, getMaxCompletionTokens, } from "../custom/modelRequestDefaults.js";
 import { evaluateToolPolicy, getPrimaryMaxToolCalls, } from "./toolPolicy.js";
 import { trimAgentHistory, } from "./trimAgentHistory.js";
-import { AGENT_TOOL_DEFINITIONS } from "./toolSchemas.js";
+import { buildAgentToolDefinitions } from "./toolSchemas.js";
 const MAX_LOOP_TURNS = 25;
 const LENGTH_RETRY_NUDGE = "Your previous response was truncated (length limit). Call one tool with minimal arguments.";
 function buildUserMessage(userPrompt, imageDataUrls) {
@@ -100,7 +101,7 @@ function buildEarlyFinishResult(input) {
     };
 }
 async function applyDeterministicCompletionGate(input) {
-    const gate = evaluateHarnessCompletionGate({
+    const gate = await evaluateHarnessCompletionGate({
         changedFiles: input.allowlistedFiles,
         toolCallCount: input.policyState.toolCallCount,
         modelTurnCount: input.modelTurnCount,
@@ -108,12 +109,17 @@ async function applyDeterministicCompletionGate(input) {
         selectedDom: input.selectedDom,
         completion: input.completion,
         deferredFinishCount: input.completionState.deferredFinishCount,
+        repoPath: input.repoPath,
     });
     if (gate.action === "continue") {
         input.completionState.deferredFinishCount += 1;
-        emitAgentReflectionThinking(input.bus, input.modelTurnCount, gate.continueReason === "style_only_incomplete"
-            ? "Style changes are in place; continuing to wire components and config."
-            : undefined);
+        emitAgentReflectionThinking(input.bus, input.modelTurnCount, gate.continueReason === "asset_publish_incomplete"
+            ? "Wiring references an image; continuing until publish_reference_image writes public/assets."
+            : gate.continueReason === "style_only_incomplete"
+                ? "Style changes are in place; continuing to wire components and config."
+                : gate.continueReason === "completion_callback"
+                    ? "Completion rules not satisfied; continuing until required files change."
+                    : undefined);
         input.bus?.emit({
             type: "run.continue",
             reason: gate.continueReason ?? "style_only_incomplete",
@@ -125,7 +131,11 @@ async function applyDeterministicCompletionGate(input) {
         });
         input.messages.push({
             role: "user",
-            content: getWiringIncompleteNudge(),
+            content: gate.continueReason === "asset_publish_incomplete"
+                ? getAssetPublishIncompleteNudge()
+                : gate.continueReason === "completion_callback"
+                    ? getCompletionRulesIncompleteNudge()
+                    : getWiringIncompleteNudge(),
         });
         return undefined;
     }
@@ -172,7 +182,7 @@ async function tryHarnessEarlyFinish(input) {
     if (allowlistedFiles.length === 0) {
         return undefined;
     }
-    const gateContext = evaluateHarnessCompletionGate({
+    const gateContext = await evaluateHarnessCompletionGate({
         changedFiles: allowlistedFiles,
         toolCallCount: input.policyState.toolCallCount,
         modelTurnCount: input.modelTurnCount,
@@ -180,6 +190,7 @@ async function tryHarnessEarlyFinish(input) {
         selectedDom: input.selectedDom,
         completion: input.completion,
         deferredFinishCount: input.completionState.deferredFinishCount,
+        repoPath: input.repoPath,
     });
     const useLlm = shouldUseLlmCompletionEvaluator({
         harnessMode: input.harnessMode,
@@ -316,6 +327,7 @@ async function tryHarnessEarlyFinish(input) {
         selectedDom: input.selectedDom,
         completion: input.completion,
         completionState: input.completionState,
+        repoPath: input.repoPath,
     });
 }
 /** Runs a multi-turn tool-calling loop against an OpenAI-compatible chat API. */
@@ -334,235 +346,295 @@ export async function runAgentToolLoop(input) {
         recentToolResults: [],
         evaluationCallCount: 0,
     };
+    const resolvedHostTools = resolveHostToolsForRun({
+        hostTools: input.hostTools,
+        includeAttachmentUrlsTool: Boolean(input.attachments?.length),
+    });
+    registerHostToolsForRun(resolvedHostTools);
+    const toolDefinitions = buildAgentToolDefinitions(hostToolsToOpenAiDefinitions(resolvedHostTools));
     const toolCtx = {
         repoPath: input.repoPath,
         allowedWritePaths: input.allowedWritePaths,
         enforceAllowlist: input.enforceAllowlist,
+        apiKey: input.apiKey,
+        signal: input.signal,
+        imageGenCount: 0,
+        attachments: input.attachments,
+        selectedDom: input.selectedDom,
     };
-    for (let turn = 0; turn < MAX_LOOP_TURNS; turn += 1) {
-        throwIfCancelled(input.signal);
-        const modelTurnCount = turn + 1;
-        if (policyState.abortReason) {
-            const early = await tryHarnessEarlyFinish({
-                harnessMode: input.harnessMode,
-                allowedWritePaths: input.allowedWritePaths,
-                repoPath: input.repoPath,
-                workspaceCheckpoint: input.workspaceCheckpoint,
-                bus: input.bus,
-                policyState,
-                editsApplied,
-                lastAssistantText,
-                loopStartMs,
-                lastUsage,
-                messages,
-                modelTurnCount,
-                hasVision: input.hasVision,
-                selectedDom: input.selectedDom,
-                completion: input.completion,
-                completionAuto: input.completionAuto,
-                completionEvaluationEnabled: input.completionEvaluationEnabled,
-                completionConfidenceThreshold: input.completionConfidenceThreshold,
-                referenceImages: input.referenceImages,
-                ownerRequest: input.ownerRequest,
-                model: input.model,
-                timeoutMs: input.timeoutMs,
-                signal: input.signal,
-                completionState,
-            });
-            if (early) {
-                return early;
+    try {
+        for (let turn = 0; turn < MAX_LOOP_TURNS; turn += 1) {
+            throwIfCancelled(input.signal);
+            const modelTurnCount = turn + 1;
+            if (policyState.abortReason) {
+                const early = await tryHarnessEarlyFinish({
+                    harnessMode: input.harnessMode,
+                    allowedWritePaths: input.allowedWritePaths,
+                    repoPath: input.repoPath,
+                    workspaceCheckpoint: input.workspaceCheckpoint,
+                    bus: input.bus,
+                    policyState,
+                    editsApplied,
+                    lastAssistantText,
+                    loopStartMs,
+                    lastUsage,
+                    messages,
+                    modelTurnCount,
+                    hasVision: input.hasVision,
+                    selectedDom: input.selectedDom,
+                    completion: input.completion,
+                    completionAuto: input.completionAuto,
+                    completionEvaluationEnabled: input.completionEvaluationEnabled,
+                    completionConfidenceThreshold: input.completionConfidenceThreshold,
+                    referenceImages: input.referenceImages,
+                    ownerRequest: input.ownerRequest,
+                    model: input.model,
+                    timeoutMs: input.timeoutMs,
+                    signal: input.signal,
+                    completionState,
+                });
+                if (early) {
+                    return early;
+                }
+                break;
             }
-            break;
-        }
-        const trimmedMessages = trimAgentHistory(messages);
-        let maxCompletionTokensOverride;
-        let lengthRetryUsed = false;
-        input.bus?.emit({
-            type: "model.attempt",
-            attempt: turn + 1,
-            maxAttempts: MAX_LOOP_TURNS,
-        });
-        emitAgentPlanningThinking(input.bus, turn + 1);
-        const requestBody = {
-            model: input.modelId,
-            messages: trimmedMessages,
-            tools: AGENT_TOOL_DEFINITIONS,
-            tool_choice: "auto",
-            temperature: 0.2,
-        };
-        applyCustomModelRequestDefaults(requestBody, {
-            profile,
-            modelId: input.modelId,
-            maxCompletionTokensOverride,
-        });
-        const callModel = async () => {
+            const trimmedMessages = trimAgentHistory(messages);
+            let maxCompletionTokensOverride;
+            let lengthRetryUsed = false;
             input.bus?.emit({
-                type: "model.request",
-                provider: "custom",
-                model: input.modelId,
-                hasVision: Boolean(input.hasVision),
+                type: "model.attempt",
+                attempt: turn + 1,
+                maxAttempts: MAX_LOOP_TURNS,
             });
-            const { value: result } = await withApiConcurrencyLimit((queueWaitMs) => postJsonWithRetry({
-                url: `${input.baseURL}/chat/completions`,
-                headers: {
-                    Authorization: `Bearer ${input.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: requestBody,
-                timeoutMs: input.timeoutMs ?? 300_000,
-                signal: input.signal,
-            }, queueWaitMs));
-            if (result.ok && result.data) {
-                const content = result.data.choices?.[0]?.message?.content?.trim() ?? "";
-                input.bus?.emit({
-                    type: "model.response",
-                    contentPreview: content.slice(0, 500),
-                    timingMs: result.totalMs,
-                    httpRetries: result.retries,
-                });
-            }
-            return result;
-        };
-        let apiResult = input.bus
-            ? await input.bus.withTool("model_completion", { turn: turn + 1, model: input.modelId }, callModel)
-            : await callModel();
-        throwIfCancelled(input.signal);
-        if (!apiResult.ok || !apiResult.data) {
-            const rateLimit = apiResult.rateLimit;
-            return {
-                ok: false,
-                response: "",
-                summary: rateLimit ? "MiniMax rate limit exceeded" : "Model API request failed",
-                editsApplied,
-                toolCallCount: policyState.toolCallCount,
-                error: {
-                    message: rateLimit
-                        ? formatRateLimitReport(rateLimit)
-                        : `${apiResult.errorMessage ?? "Model API request failed"} | ${formatTimingReport(apiResult)}`,
-                    code: rateLimit ? "RATE_LIMIT" : "PROVIDER_ERROR",
-                },
+            emitAgentPlanningThinking(input.bus, turn + 1);
+            const requestBody = {
+                model: input.modelId,
+                messages: trimmedMessages,
+                tools: toolDefinitions,
+                tool_choice: "auto",
+                temperature: 0.2,
             };
-        }
-        let payload = apiResult.data;
-        let choice = payload.choices?.[0];
-        let finishReason = choice?.finish_reason;
-        if (finishReason === "length" && !lengthRetryUsed) {
-            lengthRetryUsed = true;
-            const currentCap = requestBody.max_completion_tokens ??
-                getMaxCompletionTokens(profile);
-            maxCompletionTokensOverride = bumpMaxCompletionTokensForLengthRetry(profile, currentCap);
-            messages.push({ role: "user", content: LENGTH_RETRY_NUDGE });
             applyCustomModelRequestDefaults(requestBody, {
                 profile,
                 modelId: input.modelId,
                 maxCompletionTokensOverride,
             });
-            requestBody.messages = trimAgentHistory(messages);
-            input.bus?.emit({
-                type: "model.repair",
-                reason: "length",
-                priorOutputSnippet: (choice?.message?.content ?? "").slice(0, 200),
-            });
-            apiResult = input.bus
-                ? await input.bus.withTool("model_completion", { turn: turn + 1, model: input.modelId, lengthRetry: true }, callModel)
+            const callModel = async () => {
+                input.bus?.emit({
+                    type: "model.request",
+                    provider: "custom",
+                    model: input.modelId,
+                    hasVision: Boolean(input.hasVision),
+                });
+                const { value: result } = await withApiConcurrencyLimit((queueWaitMs) => postJsonWithRetry({
+                    url: `${input.baseURL}/chat/completions`,
+                    headers: {
+                        Authorization: `Bearer ${input.apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: requestBody,
+                    timeoutMs: input.timeoutMs ?? 300_000,
+                    signal: input.signal,
+                }, queueWaitMs));
+                if (result.ok && result.data) {
+                    const content = result.data.choices?.[0]?.message?.content?.trim() ?? "";
+                    input.bus?.emit({
+                        type: "model.response",
+                        contentPreview: content.slice(0, 500),
+                        timingMs: result.totalMs,
+                        httpRetries: result.retries,
+                    });
+                }
+                return result;
+            };
+            let apiResult = input.bus
+                ? await input.bus.withTool("model_completion", { turn: turn + 1, model: input.modelId }, callModel)
                 : await callModel();
+            throwIfCancelled(input.signal);
             if (!apiResult.ok || !apiResult.data) {
                 const rateLimit = apiResult.rateLimit;
                 return {
                     ok: false,
-                    response: lastAssistantText,
-                    summary: "Model API request failed after length retry",
+                    response: "",
+                    summary: rateLimit ? "MiniMax rate limit exceeded" : "Model API request failed",
                     editsApplied,
                     toolCallCount: policyState.toolCallCount,
                     error: {
-                        message: rateLimit?.message ??
-                            apiResult.errorMessage ??
-                            "Model API request failed",
+                        message: rateLimit
+                            ? formatRateLimitReport(rateLimit)
+                            : `${apiResult.errorMessage ?? "Model API request failed"} | ${formatTimingReport(apiResult)}`,
                         code: rateLimit ? "RATE_LIMIT" : "PROVIDER_ERROR",
                     },
                 };
             }
-            payload = apiResult.data;
-            choice = payload.choices?.[0];
-            finishReason = choice?.finish_reason;
-        }
-        lastUsage = payload.usage;
-        const message = choice?.message;
-        if (!message) {
-            return {
-                ok: false,
-                response: lastAssistantText,
-                summary: "Model returned empty message",
-                editsApplied,
-                toolCallCount: policyState.toolCallCount,
-                error: { message: "Empty model response", code: "PROVIDER_ERROR" },
-            };
-        }
-        const toolCalls = message.tool_calls ?? [];
-        const assistantContent = typeof message.content === "string" ? message.content.trim() : "";
-        emitAgentRawModelTrace(input.bus, turn + 1, "custom", message);
-        if (assistantContent) {
-            lastAssistantText = assistantContent;
-            input.bus?.emit(buildAssistantEvent(assistantContent));
-        }
-        messages.push(toAssistantHistoryMessage(message));
-        if (toolCalls.length > 0) {
-            emitAgentToolSelectionThinking(input.bus, turn + 1, toolCalls.map((tc) => tc.function.name));
-        }
-        if (toolCalls.length === 0) {
-            const harnessOk = input.harnessMode && input.allowedWritePaths?.length
-                ? editsApplied > 0
-                : editsApplied > 0 || assistantContent.length > 0;
-            return {
-                ok: harnessOk,
-                response: assistantContent || lastAssistantText || "Agent completed",
-                summary: editsApplied > 0 ? `Applied ${editsApplied} edit(s)` : assistantContent.slice(0, 200),
-                editsApplied,
-                toolCallCount: policyState.toolCallCount,
-                usage: lastUsage,
-            };
-        }
-        let mutatingEditsThisTurn = 0;
-        for (const toolCall of toolCalls) {
-            throwIfCancelled(input.signal);
-            const toolName = toolCall.function.name;
-            policyState = evaluateToolPolicy(toolName, policyState, maxToolCalls);
-            if (policyState.abortReason) {
+            let payload = apiResult.data;
+            let choice = payload.choices?.[0];
+            let finishReason = choice?.finish_reason;
+            if (finishReason === "length" && !lengthRetryUsed) {
+                lengthRetryUsed = true;
+                const currentCap = requestBody.max_completion_tokens ??
+                    getMaxCompletionTokens(profile);
+                maxCompletionTokensOverride = bumpMaxCompletionTokensForLengthRetry(profile, currentCap);
+                messages.push({ role: "user", content: LENGTH_RETRY_NUDGE });
+                applyCustomModelRequestDefaults(requestBody, {
+                    profile,
+                    modelId: input.modelId,
+                    maxCompletionTokensOverride,
+                });
+                requestBody.messages = trimAgentHistory(messages);
+                input.bus?.emit({
+                    type: "model.repair",
+                    reason: "length",
+                    priorOutputSnippet: (choice?.message?.content ?? "").slice(0, 200),
+                });
+                apiResult = input.bus
+                    ? await input.bus.withTool("model_completion", { turn: turn + 1, model: input.modelId, lengthRetry: true }, callModel)
+                    : await callModel();
+                if (!apiResult.ok || !apiResult.data) {
+                    const rateLimit = apiResult.rateLimit;
+                    return {
+                        ok: false,
+                        response: lastAssistantText,
+                        summary: "Model API request failed after length retry",
+                        editsApplied,
+                        toolCallCount: policyState.toolCallCount,
+                        error: {
+                            message: rateLimit?.message ??
+                                apiResult.errorMessage ??
+                                "Model API request failed",
+                            code: rateLimit ? "RATE_LIMIT" : "PROVIDER_ERROR",
+                        },
+                    };
+                }
+                payload = apiResult.data;
+                choice = payload.choices?.[0];
+                finishReason = choice?.finish_reason;
+            }
+            lastUsage = payload.usage;
+            const message = choice?.message;
+            if (!message) {
+                return {
+                    ok: false,
+                    response: lastAssistantText,
+                    summary: "Model returned empty message",
+                    editsApplied,
+                    toolCallCount: policyState.toolCallCount,
+                    error: { message: "Empty model response", code: "PROVIDER_ERROR" },
+                };
+            }
+            const toolCalls = message.tool_calls ?? [];
+            const assistantContent = typeof message.content === "string" ? message.content.trim() : "";
+            emitAgentRawModelTrace(input.bus, turn + 1, "custom", message);
+            if (assistantContent) {
+                lastAssistantText = assistantContent;
+                input.bus?.emit(buildAssistantEvent(assistantContent));
+            }
+            messages.push(toAssistantHistoryMessage(message));
+            if (toolCalls.length > 0) {
+                emitAgentToolSelectionThinking(input.bus, turn + 1, toolCalls.map((tc) => tc.function.name));
+            }
+            if (toolCalls.length === 0) {
+                const harnessOk = input.harnessMode && input.allowedWritePaths?.length
+                    ? editsApplied > 0
+                    : editsApplied > 0 || assistantContent.length > 0;
+                return {
+                    ok: harnessOk,
+                    response: assistantContent || lastAssistantText || "Agent completed",
+                    summary: editsApplied > 0 ? `Applied ${editsApplied} edit(s)` : assistantContent.slice(0, 200),
+                    editsApplied,
+                    toolCallCount: policyState.toolCallCount,
+                    usage: lastUsage,
+                };
+            }
+            let mutatingEditsThisTurn = 0;
+            for (const toolCall of toolCalls) {
+                throwIfCancelled(input.signal);
+                const toolName = toolCall.function.name;
+                policyState = evaluateToolPolicy(toolName, policyState, maxToolCalls);
+                if (policyState.abortReason) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: `Tool blocked: ${policyState.abortReason}`,
+                    });
+                    break;
+                }
+                const args = parseToolArguments(toolCall.function.arguments);
+                const result = await executeAgentTool(toolName, args, toolCtx, input.bus);
+                const toolPath = typeof args.path === "string"
+                    ? args.path
+                    : typeof args.file_path === "string"
+                        ? args.file_path
+                        : typeof args.destPath === "string"
+                            ? args.destPath
+                            : typeof args.dest_path === "string"
+                                ? args.dest_path
+                                : typeof result.path === "string"
+                                    ? result.path
+                                    : undefined;
+                const meta = result.meta ?? {};
+                const publicUrl = typeof meta.publicUrl === "string" ? meta.publicUrl : undefined;
+                const destPath = typeof meta.destPath === "string" ? meta.destPath : toolPath;
+                completionState.recentToolResults.push({
+                    name: toolName,
+                    ok: result.ok,
+                    output: result.output,
+                    path: destPath,
+                    publicUrl,
+                    meta,
+                });
+                if (completionState.recentToolResults.length > 5) {
+                    completionState.recentToolResults.shift();
+                }
+                if (result.applied) {
+                    editsApplied += 1;
+                    mutatingEditsThisTurn += 1;
+                    invalidateWorkspaceCheckpointCache(input.workspaceCheckpoint);
+                }
                 messages.push({
                     role: "tool",
                     tool_call_id: toolCall.id,
-                    content: `Tool blocked: ${policyState.abortReason}`,
+                    content: result.output,
                 });
-                break;
             }
-            const args = parseToolArguments(toolCall.function.arguments);
-            const result = await executeAgentTool(toolName, args, toolCtx, input.bus);
-            const toolPath = typeof args.path === "string"
-                ? args.path
-                : typeof args.file_path === "string"
-                    ? args.file_path
-                    : undefined;
-            completionState.recentToolResults.push({
-                name: toolName,
-                ok: result.ok,
-                output: result.output,
-                path: toolPath,
-            });
-            if (completionState.recentToolResults.length > 5) {
-                completionState.recentToolResults.shift();
+            if (mutatingEditsThisTurn > 0) {
+                const early = await tryHarnessEarlyFinish({
+                    harnessMode: input.harnessMode,
+                    allowedWritePaths: input.allowedWritePaths,
+                    repoPath: input.repoPath,
+                    workspaceCheckpoint: input.workspaceCheckpoint,
+                    bus: input.bus,
+                    policyState,
+                    editsApplied,
+                    lastAssistantText,
+                    loopStartMs,
+                    lastUsage,
+                    messages,
+                    modelTurnCount,
+                    hasVision: input.hasVision,
+                    selectedDom: input.selectedDom,
+                    completion: input.completion,
+                    completionAuto: input.completionAuto,
+                    completionEvaluationEnabled: input.completionEvaluationEnabled,
+                    completionConfidenceThreshold: input.completionConfidenceThreshold,
+                    referenceImages: input.referenceImages,
+                    ownerRequest: input.ownerRequest,
+                    model: input.model,
+                    timeoutMs: input.timeoutMs,
+                    signal: input.signal,
+                    completionState,
+                });
+                if (early) {
+                    return early;
+                }
             }
-            if (result.applied) {
-                editsApplied += 1;
-                mutatingEditsThisTurn += 1;
-                invalidateWorkspaceCheckpointCache(input.workspaceCheckpoint);
+            if (editsApplied > 0 && toolCalls.every((call) => !isMutatingTool(call.function.name))) {
+                continue;
             }
-            messages.push({
-                role: "tool",
-                tool_call_id: toolCall.id,
-                content: result.output,
-            });
         }
-        if (mutatingEditsThisTurn > 0) {
+        if (input.harnessMode &&
+            input.allowedWritePaths?.length &&
+            editsApplied > 0) {
             const early = await tryHarnessEarlyFinish({
                 harnessMode: input.harnessMode,
                 allowedWritePaths: input.allowedWritePaths,
@@ -575,7 +647,7 @@ export async function runAgentToolLoop(input) {
                 loopStartMs,
                 lastUsage,
                 messages,
-                modelTurnCount,
+                modelTurnCount: MAX_LOOP_TURNS,
                 hasVision: input.hasVision,
                 selectedDom: input.selectedDom,
                 completion: input.completion,
@@ -593,60 +665,27 @@ export async function runAgentToolLoop(input) {
                 return early;
             }
         }
-        if (editsApplied > 0 && toolCalls.every((call) => !isMutatingTool(call.function.name))) {
-            continue;
-        }
-    }
-    if (input.harnessMode &&
-        input.allowedWritePaths?.length &&
-        editsApplied > 0) {
-        const early = await tryHarnessEarlyFinish({
-            harnessMode: input.harnessMode,
-            allowedWritePaths: input.allowedWritePaths,
-            repoPath: input.repoPath,
-            workspaceCheckpoint: input.workspaceCheckpoint,
-            bus: input.bus,
-            policyState,
+        return {
+            ok: editsApplied > 0,
+            response: lastAssistantText || "Agent loop ended",
+            summary: editsApplied > 0
+                ? `Applied ${editsApplied} edit(s) via tools`
+                : policyState.abortReason ?? "Agent loop ended without edits",
             editsApplied,
-            lastAssistantText,
-            loopStartMs,
-            lastUsage,
-            messages,
-            modelTurnCount: MAX_LOOP_TURNS,
-            hasVision: input.hasVision,
-            selectedDom: input.selectedDom,
-            completion: input.completion,
-            completionAuto: input.completionAuto,
-            completionEvaluationEnabled: input.completionEvaluationEnabled,
-            completionConfidenceThreshold: input.completionConfidenceThreshold,
-            referenceImages: input.referenceImages,
-            ownerRequest: input.ownerRequest,
-            model: input.model,
-            timeoutMs: input.timeoutMs,
-            signal: input.signal,
-            completionState,
-        });
-        if (early) {
-            return early;
-        }
+            toolCallCount: policyState.toolCallCount,
+            abortReason: policyState.abortReason,
+            usage: lastUsage,
+            error: editsApplied === 0
+                ? {
+                    message: policyState.abortReason ?? "No edits applied",
+                    code: "EDIT_NOT_APPLIED",
+                }
+                : undefined,
+        };
+    }
+    finally {
+        clearHostToolsForRun();
     }
-    return {
-        ok: editsApplied > 0,
-        response: lastAssistantText || "Agent loop ended",
-        summary: editsApplied > 0
-            ? `Applied ${editsApplied} edit(s) via tools`
-            : policyState.abortReason ?? "Agent loop ended without edits",
-        editsApplied,
-        toolCallCount: policyState.toolCallCount,
-        abortReason: policyState.abortReason,
-        usage: lastUsage,
-        error: editsApplied === 0
-            ? {
-                message: policyState.abortReason ?? "No edits applied",
-                code: "EDIT_NOT_APPLIED",
-            }
-            : undefined,
-    };
 }
 function isMutatingTool(toolName) {
     const name = toolName.toLowerCase();