@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.71

package/dist/heart/core.js

@@ -8,6 +8,7 @@ exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
 exports.stripLastToolCalls = stripLastToolCalls;
+exports.repairOrphanedToolCalls = repairOrphanedToolCalls;
 exports.isTransientError = isTransientError;
 exports.classifyTransientError = classifyTransientError;
 exports.runAgent = runAgent;
@@ -15,9 +16,6 @@ const config_1 = require("./config");
 const identity_1 = require("./identity");
 const tools_1 = require("../repertoire/tools");
 const channel_1 = require("../mind/friends/channel");
-// Kick detection preserved but disabled — see comment in agent loop below.
-// import { detectKick } from "./kicks";
-// import type { KickReason } from "./kicks";
 const runtime_1 = require("../nerves/runtime");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
@@ -26,13 +24,43 @@ const anthropic_1 = require("./providers/anthropic");
 const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
+const github_copilot_1 = require("./providers/github-copilot");
 let _providerRuntime = null;
+function getProviderRuntimeFingerprint() {
+    const provider = (0, identity_1.loadAgentConfig)().provider;
+    /* v8 ignore next -- switch: not all provider branches exercised in CI @preserve */
+    switch (provider) {
+        case "azure": {
+            const { apiKey, endpoint, deployment, modelName, apiVersion, managedIdentityClientId } = (0, config_1.getAzureConfig)();
+            return JSON.stringify({ provider, apiKey, endpoint, deployment, modelName, apiVersion, managedIdentityClientId });
+        }
+        case "anthropic": {
+            const { model, setupToken } = (0, config_1.getAnthropicConfig)();
+            return JSON.stringify({ provider, model, setupToken });
+        }
+        case "minimax": {
+            const { apiKey, model } = (0, config_1.getMinimaxConfig)();
+            return JSON.stringify({ provider, apiKey, model });
+        }
+        case "openai-codex": {
+            const { model, oauthAccessToken } = (0, config_1.getOpenAICodexConfig)();
+            return JSON.stringify({ provider, model, oauthAccessToken });
+        }
+        /* v8 ignore start -- fingerprint: tested via provider init tests @preserve */
+        case "github-copilot": {
+            const { model, githubToken, baseUrl } = (0, config_1.getGithubCopilotConfig)();
+            return JSON.stringify({ provider, model, githubToken, baseUrl });
+        }
+        /* v8 ignore stop */
+    }
+}
 function createProviderRegistry() {
     const factories = {
         azure: azure_1.createAzureProviderRuntime,
         anthropic: anthropic_1.createAnthropicProviderRuntime,
         minimax: minimax_1.createMinimaxProviderRuntime,
         "openai-codex": openai_codex_1.createOpenAICodexProviderRuntime,
+        "github-copilot": github_copilot_1.createGithubCopilotProviderRuntime,
     };
     return {
         resolve() {
@@ -42,42 +70,44 @@ function createProviderRegistry() {
     };
 }
 function getProviderRuntime() {
-    if (!_providerRuntime) {
-        try {
-            _providerRuntime = createProviderRegistry().resolve();
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: msg,
-                meta: {},
-            });
-            // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
-            console.error(`\n[fatal] ${msg}\n`);
-            process.exit(1);
-            throw new Error("unreachable");
-        }
-        if (!_providerRuntime) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: "provider runtime could not be initialized.",
-                meta: {},
-            });
-            process.exit(1);
-            throw new Error("unreachable");
+    try {
+        const fingerprint = getProviderRuntimeFingerprint();
+        if (!_providerRuntime || _providerRuntime.fingerprint !== fingerprint) {
+            const runtime = createProviderRegistry().resolve();
+            _providerRuntime = runtime ? { fingerprint, runtime } : null;
         }
     }
-    return _providerRuntime;
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: msg,
+            meta: {},
+        });
+        // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
+        console.error(`\n[fatal] ${msg}\n`);
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    if (!_providerRuntime) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: "provider runtime could not be initialized.",
+            meta: {},
+        });
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    return _providerRuntime.runtime;
 }
 /**
- * Clear the cached provider runtime so the next call to getProviderRuntime()
- * re-creates it from current config. Used by the adoption specialist to
- * switch provider context without restarting the process.
+ * Clear the cached provider runtime so the next access re-creates it from
+ * current config. Runtime access also auto-refreshes when the selected
+ * provider fingerprint changes on disk.
  */
 function resetProviderRuntime() {
     _providerRuntime = null;
@@ -104,14 +134,19 @@ function createSummarize() {
     };
 }
 function getProviderDisplayLabel() {
-    const model = getModel();
+    const provider = (0, identity_1.loadAgentConfig)().provider;
     const providerLabelBuilders = {
-        azure: () => `azure openai (${(0, config_1.getAzureConfig)().deployment || "default"}, model: ${model})`,
-        anthropic: () => `anthropic (${model})`,
-        minimax: () => `minimax (${model})`,
-        "openai-codex": () => `openai codex (${model})`,
+        azure: () => {
+            const config = (0, config_1.getAzureConfig)();
+            return `azure openai (${config.deployment || "default"}, model: ${config.modelName || "unknown"})`;
+        },
+        anthropic: () => `anthropic (${(0, config_1.getAnthropicConfig)().model || "unknown"})`,
+        minimax: () => `minimax (${(0, config_1.getMinimaxConfig)().model || "unknown"})`,
+        "openai-codex": () => `openai codex (${(0, config_1.getOpenAICodexConfig)().model || "unknown"})`,
+        /* v8 ignore next -- branch: tested via display label unit test @preserve */
+        "github-copilot": () => `github copilot (${(0, config_1.getGithubCopilotConfig)().model || "unknown"})`,
     };
-    return providerLabelBuilders[getProvider()]();
+    return providerLabelBuilders[provider]();
 }
 // Re-export tools, execTool, summarizeArgs from ./tools for backward compat
 var tools_2 = require("../repertoire/tools");
@@ -128,6 +163,35 @@ Object.defineProperty(exports, "toResponsesTools", { enumerable: true, get: func
 // Re-export prompt functions for backward compat
 var prompt_2 = require("../mind/prompt");
 Object.defineProperty(exports, "buildSystem", { enumerable: true, get: function () { return prompt_2.buildSystem; } });
+function parseFinalAnswerPayload(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (typeof parsed === "string") {
+            return { answer: parsed };
+        }
+        if (!parsed || typeof parsed !== "object") {
+            return {};
+        }
+        const answer = typeof parsed.answer === "string" ? parsed.answer : undefined;
+        const rawIntent = parsed.intent;
+        const intent = rawIntent === "complete" || rawIntent === "blocked" || rawIntent === "direct_reply"
+            ? rawIntent
+            : undefined;
+        return { answer, intent };
+    }
+    catch {
+        return {};
+    }
+}
+function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp) {
+    if (mustResolveBeforeHandoff && !intent) {
+        return "your final_answer is missing required intent. when you must keep going until done or blocked, call final_answer again with answer plus intent=complete, blocked, or direct_reply.";
+    }
+    if (mustResolveBeforeHandoff && intent === "direct_reply" && !sawSteeringFollowUp) {
+        return "your final_answer used intent=direct_reply without a newer steering follow-up. continue the unresolved work, or call final_answer again with intent=complete or blocked when appropriate.";
+    }
+    return "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+}
 // Re-export kick utilities for backward compat
 var kicks_1 = require("./kicks");
 Object.defineProperty(exports, "hasToolIntent", { enumerable: true, get: function () { return kicks_1.hasToolIntent; } });
@@ -160,6 +224,68 @@ function stripLastToolCalls(messages) {
         }
     }
 }
+// Roles that end a tool-result scan. When scanning forward from an assistant
+// message, stop at the next assistant or user message (tool results must be
+// adjacent to their originating assistant message).
+const TOOL_SCAN_BOUNDARY_ROLES = new Set(["assistant", "user"]);
+// Repair orphaned tool_calls and tool results anywhere in the message history.
+// 1. If an assistant message has tool_calls but missing tool results, inject synthetic error results.
+// 2. If a tool result's tool_call_id doesn't match any tool_calls in a preceding assistant message, remove it.
+// This prevents 400 errors from the API after an aborted turn.
+function repairOrphanedToolCalls(messages) {
+    // Pass 1: collect all valid tool_call IDs from assistant messages
+    const validCallIds = new Set();
+    for (const msg of messages) {
+        if (msg.role === "assistant") {
+            const asst = msg;
+            if (asst.tool_calls) {
+                for (const tc of asst.tool_calls)
+                    validCallIds.add(tc.id);
+            }
+        }
+    }
+    // Pass 2: remove orphaned tool results (tool_call_id not in any assistant's tool_calls)
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "tool") {
+            const toolMsg = messages[i];
+            if (!validCallIds.has(toolMsg.tool_call_id)) {
+                messages.splice(i, 1);
+            }
+        }
+    }
+    // Pass 3: inject synthetic results for tool_calls missing their tool results
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role !== "assistant")
+            continue;
+        const asst = msg;
+        if (!asst.tool_calls || asst.tool_calls.length === 0)
+            continue;
+        // Collect tool result IDs that follow this assistant message
+        const resultIds = new Set();
+        for (let j = i + 1; j < messages.length; j++) {
+            const following = messages[j];
+            if (following.role === "tool") {
+                resultIds.add(following.tool_call_id);
+            }
+            else if (TOOL_SCAN_BOUNDARY_ROLES.has(following.role)) {
+                break;
+            }
+        }
+        const missing = asst.tool_calls.filter((tc) => !resultIds.has(tc.id));
+        if (missing.length > 0) {
+            const syntheticResults = missing.map((tc) => ({
+                role: "tool",
+                tool_call_id: tc.id,
+                content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+            }));
+            let insertAt = i + 1;
+            while (insertAt < messages.length && messages[insertAt].role === "tool")
+                insertAt++;
+            messages.splice(insertAt, 0, ...syntheticResults);
+        }
+    }
+}
 // Detect context overflow errors from Azure or MiniMax
 function isContextOverflow(err) {
     if (!(err instanceof Error))
@@ -242,7 +368,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // so turn execution remains consistent and non-fatal.
     if (channel) {
         try {
-            const refreshed = await (0, prompt_1.buildSystem)(channel, options, currentContext);
+            const buildSystemOptions = {
+                ...options,
+                providerCapabilities: providerRuntime.capabilities,
+                supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
+            };
+            const refreshed = await (0, prompt_1.buildSystem)(channel, buildSystemOptions, currentContext);
             upsertSystemPrompt(messages, refreshed);
         }
         catch (error) {
@@ -265,20 +396,30 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         }
     }
     await (0, associative_recall_1.injectAssociativeRecall)(messages);
-    // kickCount and lastKickReason preserved but unused while kick detection is disabled.
-    // let kickCount = 0;
-    // let lastKickReason: KickReason | null = null;
     let done = false;
     let lastUsage;
     let overflowRetried = false;
     let retryCount = 0;
+    let outcome = "complete";
+    let completion;
+    let sawSteeringFollowUp = false;
+    let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
+    let currentReasoningEffort = "medium";
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
     }
     catch { /* unsupported */ }
     const toolPreferences = currentContext?.friend?.toolPreferences;
-    const baseTools = (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined);
+    const baseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext, providerRuntime.capabilities);
+    // Augment tool context with reasoning effort controls from provider
+    const augmentedToolContext = options?.toolContext
+        ? {
+            ...options.toolContext,
+            supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
+            setReasoningEffort: (level) => { currentReasoningEffort = level; },
+        }
+        : undefined;
     // Rebase provider-owned turn state from canonical messages at user-turn start.
     // This prevents stale provider caches from replaying prior-turn context.
     providerRuntime.resetTurnState(messages);
@@ -287,9 +428,23 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         // so the model can signal completion. With tool_choice: required, the
         // model must call a tool every turn — final_answer is how it exits.
         // Overridable via options.toolChoiceRequired = false (e.g. CLI).
-        const activeTools = toolChoiceRequired ? [...baseTools, tools_1.finalAnswerTool] : baseTools;
+        const activeTools = toolChoiceRequired
+            ? [...baseTools, ...(currentContext?.isGroupChat ? [tools_1.noResponseTool] : []), tools_1.finalAnswerTool]
+            : baseTools;
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
+            const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
+            if (hasSupersedingFollowUp) {
+                mustResolveBeforeHandoffActive = false;
+                options?.setMustResolveBeforeHandoff?.(false);
+                outcome = "superseded";
+                break;
+            }
+            if (steeringFollowUps.some((followUp) => followUp.effect === "set_no_handoff")) {
+                mustResolveBeforeHandoffActive = true;
+                options?.setMustResolveBeforeHandoff?.(true);
+            }
+            sawSteeringFollowUp = true;
             for (const followUp of steeringFollowUps) {
                 messages.push({ role: "user", content: followUp.text });
             }
@@ -297,8 +452,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         }
         // Yield so pending I/O (stdin Ctrl-C) can be processed between iterations
         await new Promise((r) => setImmediate(r));
-        if (signal?.aborted)
+        if (signal?.aborted) {
+            outcome = "aborted";
             break;
+        }
         try {
             callbacks.onModelStart();
             const result = await providerRuntime.streamTurn({
@@ -308,6 +465,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 signal,
                 traceId,
                 toolChoiceRequired,
+                reasoningEffort: currentReasoningEffort,
             });
             // Track usage from the latest API call
             if (result.usage)
@@ -331,49 +489,39 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             if (reasoningItems.length > 0) {
                 msg._reasoning_items = reasoningItems;
             }
+            // Store thinking blocks (Anthropic) on the assistant message for round-tripping
+            const thinkingItems = result.outputItems.filter((item) => "type" in item && (item.type === "thinking" || item.type === "redacted_thinking"));
+            if (thinkingItems.length > 0) {
+                msg._thinking_blocks = thinkingItems;
+            }
+            // Phase annotation for Codex provider
+            const hasPhaseAnnotation = providerRuntime.capabilities.has("phase-annotation");
+            const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+            if (hasPhaseAnnotation) {
+                msg.phase = isSoleFinalAnswer ? "final_answer" : "commentary";
+            }
             if (!result.toolCalls.length) {
-                // Kick detection is disabled while tool_choice: required + final_answer
-                // is the primary loop control mechanism. The model should never reach
-                // this path (tool_choice: required forces a tool call), but if it does,
-                // accept the response as-is rather than risk false-positive kicks.
-                //
-                // Preserved for future use — re-enable by uncommenting:
-                // const kick = detectKick(result.content, options);
-                // if (kick) {
-                //   kickCount++;
-                //   lastKickReason = kick.reason;
-                //   callbacks.onKick?.();
-                //   const kickContent = result.content
-                //     ? result.content + "\n\n" + kick.message
-                //     : kick.message;
-                //   messages.push({ role: "assistant", content: kickContent });
-                //   providerRuntime.resetTurnState(messages);
-                //   continue;
-                // }
+                // No tool calls — accept response as-is.
+                // (Kick detection disabled; tool_choice: required + final_answer
+                // is the primary loop control. See src/heart/kicks.ts to re-enable.)
                 messages.push(msg);
                 done = true;
             }
             else {
                 // Check for final_answer sole call: intercept before tool execution
-                const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
                 if (isSoleFinalAnswer) {
                     // Extract answer from the tool call arguments.
-                    // Supports: {"answer":"text"}, "text" (JSON string), retry on failure.
-                    let answer;
-                    try {
-                        const parsed = JSON.parse(result.toolCalls[0].arguments);
-                        if (typeof parsed === "string") {
-                            answer = parsed;
-                        }
-                        else if (parsed.answer != null) {
-                            answer = parsed.answer;
-                        }
-                        // else: valid JSON but no answer field — answer stays undefined (retry)
-                    }
-                    catch {
-                        // JSON parsing failed (e.g. truncated output) — answer stays undefined (retry)
-                    }
-                    if (answer != null) {
+                    // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
+                    const { answer, intent } = parseFinalAnswerPayload(result.toolCalls[0].arguments);
+                    const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
+                    const validTerminalIntent = intent === "complete" || intent === "blocked";
+                    const validClosure = answer != null
+                        && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
+                    if (validClosure) {
+                        completion = {
+                            answer,
+                            intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
+                        };
                         if (result.finalAnswerStreamed) {
                             // The streaming layer already parsed and emitted the answer
                             // progressively via FinalAnswerParser. Skip clearing and
@@ -386,27 +534,58 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             // Never truncate -- channel adapters handle splitting long messages.
                             callbacks.onTextChunk(answer);
                         }
-                        // Keep the full assistant message (with tool_calls) for debuggability,
-                        // plus a synthetic tool response so the conversation stays valid on resume.
                         messages.push(msg);
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: "(delivered)" });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, "(delivered)");
-                        done = true;
+                        if (validDirectReply) {
+                            const resumeWork = "direct reply delivered. resume the unresolved obligation now and keep working until you can finish or clearly report that you are blocked.";
+                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: resumeWork });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, resumeWork);
+                        }
+                        else {
+                            const delivered = "(delivered)";
+                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: delivered });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, delivered);
+                            outcome = intent === "blocked" ? "blocked" : "complete";
+                            done = true;
+                        }
                     }
                     else {
                         // Answer is undefined -- the model's final_answer was incomplete or
                         // malformed. Clear any partial streamed text or noise, then push the
                         // assistant msg + error tool result and let the model try again.
                         callbacks.onClearText?.();
-                        const retryError = "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+                        const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp);
                         messages.push(msg);
                         messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError });
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError);
                     }
                     continue;
                 }
+                // Check for no_response sole call: intercept before tool execution
+                const isSoleNoResponse = result.toolCalls.length === 1 && result.toolCalls[0].name === "no_response";
+                if (isSoleNoResponse) {
+                    let reason;
+                    try {
+                        const parsed = JSON.parse(result.toolCalls[0].arguments);
+                        if (typeof parsed?.reason === "string")
+                            reason = parsed.reason;
+                    }
+                    catch { /* ignore */ }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.no_response",
+                        message: "agent declined to respond in group chat",
+                        meta: { ...(reason ? { reason } : {}) },
+                    });
+                    messages.push(msg);
+                    const silenced = "(silenced)";
+                    messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: silenced });
+                    providerRuntime.appendToolOutput(result.toolCalls[0].id, silenced);
+                    outcome = "no_response";
+                    done = true;
+                    continue;
+                }
                 messages.push(msg);
-                // SHARED: execute tools (final_answer in mixed calls is rejected inline)
+                // SHARED: execute tools (final_answer and no_response in mixed calls are rejected inline)
                 for (const tc of result.toolCalls) {
                     if (signal?.aborted)
                         break;
@@ -417,6 +596,13 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         providerRuntime.appendToolOutput(tc.id, rejection);
                         continue;
                     }
+                    // Intercept no_response in mixed call: reject it
+                    if (tc.name === "no_response") {
+                        const rejection = "rejected: no_response must be the only tool call. call no_response alone when you want to stay silent.";
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: rejection });
+                        providerRuntime.appendToolOutput(tc.id, rejection);
+                        continue;
+                    }
                     let args = {};
                     try {
                         args = JSON.parse(tc.arguments);
@@ -444,7 +630,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     let toolResult;
                     let success;
                     try {
-                        toolResult = await (0, tools_1.execTool)(tc.name, args, options?.toolContext);
+                        const execToolFn = options?.execTool ?? tools_1.execTool;
+                        toolResult = await execToolFn(tc.name, args, augmentedToolContext ?? options?.toolContext);
                         success = true;
                     }
                     catch (e) {
@@ -461,6 +648,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             // Abort is not an error — just stop cleanly
             if (signal?.aborted) {
                 stripLastToolCalls(messages);
+                outcome = "aborted";
                 break;
             }
             // Context overflow: trim aggressively and retry once
@@ -495,6 +683,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 });
                 if (aborted) {
                     stripLastToolCalls(messages);
+                    outcome = "aborted";
                     break;
                 }
                 providerRuntime.resetTurnState(messages);
@@ -510,6 +699,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 meta: {},
             });
             stripLastToolCalls(messages);
+            outcome = "errored";
             done = true;
         }
     }
@@ -520,5 +710,5 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         message: "runAgent turn completed",
         meta: { done },
     });
-    return { usage: lastUsage };
+    return { usage: lastUsage, outcome, completion };
 }