@ouro.bot/cli 0.1.0-alpha.20 → 0.1.0-alpha.200

package/dist/heart/session-recall.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recallSession = recallSession;
+exports.searchSessionTranscript = searchSessionTranscript;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function normalizeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
+        ? String(part.text ?? "")
+        : ""))
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function normalizeSessionMessages(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages
+        .map((message) => {
+        const record = message && typeof message === "object" ? message : {};
+        return {
+            role: typeof record.role === "string" ? record.role : "",
+            content: normalizeContent(record.content),
+        };
+    })
+        .filter((message) => message.role !== "system" && message.content.length > 0);
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function buildSearchSnapshot(query, messages, includeLatestTurn = true) {
+    const lines = [`history query: "${clip(query, 120)}"`];
+    if (!includeLatestTurn) {
+        return lines.join("\n");
+    }
+    const latestUser = [...messages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...messages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function buildSearchExcerpts(messages, query, maxMatches) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery)
+        return [];
+    const candidates = [];
+    let lastMatchIndex = -2;
+    for (let i = 0; i < messages.length; i++) {
+        if (!messages[i].content.toLowerCase().includes(normalizedQuery))
+            continue;
+        if (i <= lastMatchIndex + 1)
+            continue;
+        lastMatchIndex = i;
+        const start = Math.max(0, i - 1);
+        const end = Math.min(messages.length, i + 2);
+        const excerpt = messages
+            .slice(start, end)
+            .map((message) => `[${message.role}] ${clip(message.content, 200)}`)
+            .join("\n");
+        const score = messages
+            .slice(start, end)
+            .filter((message) => message.content.toLowerCase().includes(normalizedQuery))
+            .length;
+        candidates.push({ excerpt, score, index: i });
+    }
+    const seen = new Set();
+    return candidates
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .filter((candidate) => {
+        if (seen.has(candidate.excerpt))
+            return false;
+        seen.add(candidate.excerpt);
+        return true;
+    })
+        .slice(0, maxMatches)
+        .map((candidate) => candidate.excerpt);
+}
+async function recallSession(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_recall",
+        message: "recalling session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const tailMessages = normalizeSessionMessages(parsed.messages).slice(-options.messageCount);
+    if (tailMessages.length === 0) {
+        return { kind: "empty" };
+    }
+    const transcript = tailMessages
+        .map((message) => `[${message.role}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}
+async function searchSessionTranscript(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_search",
+        message: "searching session transcript",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            query: options.query,
+            maxMatches: options.maxMatches ?? 5,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const messages = normalizeSessionMessages(parsed.messages);
+    if (messages.length === 0) {
+        return { kind: "empty" };
+    }
+    const query = options.query.trim();
+    const matches = buildSearchExcerpts(messages, query, options.maxMatches ?? 5);
+    if (matches.length === 0) {
+        return {
+            kind: "no_match",
+            query,
+            snapshot: buildSearchSnapshot(query, messages),
+        };
+    }
+    return {
+        kind: "ok",
+        query,
+        snapshot: buildSearchSnapshot(query, messages, false),
+        matches,
+    };
+}

package/dist/heart/start-of-turn-packet.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStartOfTurnPacket = buildStartOfTurnPacket;
+exports.renderStartOfTurnPacket = renderStartOfTurnPacket;
+exports.renderCompactStartOfTurnPacket = renderCompactStartOfTurnPacket;
+const runtime_1 = require("../nerves/runtime");
+const tempo_1 = require("./tempo");
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// --- Section builders (pure derivation from authored data, no embellishment) ---
+function buildPlotLine(episodes, tempo) {
+    if (episodes.length === 0)
+        return "";
+    const limit = tempo === "crisis" ? 3 : tempo === "brief" ? 2 : 5;
+    const selected = episodes.slice(0, limit);
+    const lines = selected.map((ep) => {
+        const parts = [`- ${ep.summary}`];
+        if (ep.whyItMattered && tempo !== "brief") {
+            parts[0] += ` (${ep.whyItMattered})`;
+        }
+        return parts[0];
+    });
+    return lines.join("\n");
+}
+function buildObligationsSection(obligations) {
+    if (obligations.length === 0)
+        return "";
+    return obligations
+        .map((ob) => {
+        const parts = [`- ${ob.content}`];
+        if (ob.meaning?.resumeHint) {
+            parts.push(` [hint: ${ob.meaning.resumeHint}]`);
+        }
+        if (ob.meaning?.stalenessClass && ob.meaning.stalenessClass !== "fresh") {
+            parts.push(` (${ob.meaning.stalenessClass})`);
+        }
+        if (ob.meaning?.waitingOn) {
+            parts.push(` waiting on ${ob.meaning.waitingOn.kind}: ${ob.meaning.waitingOn.target}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildCaresSection(cares) {
+    if (cares.length === 0)
+        return "";
+    return cares
+        .map((c) => {
+        const parts = [`- ${c.label}`];
+        if (c.salience !== "low") {
+            parts.push(` [${c.salience}]`);
+        }
+        if (c.currentRisk) {
+            parts.push(` risk: ${c.currentRisk}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildPresenceSection(peers) {
+    if (peers.length === 0)
+        return "";
+    return peers
+        .map((p) => `- ${p.agentName}: ${p.availability}/${p.lane}`)
+        .join("\n");
+}
+function buildResumeHint(view, obligations) {
+    // Compose from authored obligation resumeHints and top intentions
+    const hints = [];
+    const effectiveObligations = obligations ?? view.activeObligations;
+    for (const ob of effectiveObligations) {
+        if (ob.meaning?.resumeHint) {
+            hints.push(ob.meaning.resumeHint);
+        }
+    }
+    for (const intent of view.openIntentions.slice(0, 3)) {
+        hints.push(intent.content);
+    }
+    if (hints.length === 0) {
+        // Fall back to top obligation content
+        if (effectiveObligations.length > 0) {
+            hints.push(effectiveObligations[0].content);
+        }
+    }
+    if (hints.length === 0)
+        return "";
+    return hints.join("; ");
+}
+function buildStartOfTurnPacket(view, opts) {
+    const tempo = view.tempo;
+    const tokenBudget = tempo_1.TEMPO_BUDGETS[tempo];
+    const effectiveObligations = opts?.canonicalObligations ? opts.canonicalObligations.all : view.activeObligations;
+    const packet = {
+        plotLine: buildPlotLine(view.recentEpisodes, tempo),
+        obligations: buildObligationsSection(effectiveObligations),
+        cares: buildCaresSection(view.activeCares),
+        presence: buildPresenceSection(view.peerPresence),
+        resumeHint: buildResumeHint(view, opts?.canonicalObligations ? effectiveObligations : undefined),
+        tempo,
+        tokenBudget,
+        assembledAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.start_of_turn_packet_built",
+        message: `start-of-turn packet built: tempo=${tempo}`,
+        meta: {
+            tempo,
+            plotLineTokens: estimateTokens(packet.plotLine),
+            obligationsTokens: estimateTokens(packet.obligations),
+            caresTokens: estimateTokens(packet.cares),
+            presenceTokens: estimateTokens(packet.presence),
+            resumeHintTokens: estimateTokens(packet.resumeHint),
+        },
+    });
+    return packet;
+}
+/**
+ * Renders a start-of-turn packet to prompt text, respecting token budget.
+ * Truncation priority (last truncated first):
+ *   resumeHint (PROTECTED) > obligations > cares > plotLine > presence
+ * So presence is truncated first, then plotLine, then cares, then obligations.
+ * resumeHint is never truncated.
+ */
+function renderStartOfTurnPacket(packet) {
+    const budget = packet.tokenBudget;
+    // Assemble sections in priority order (highest priority first for budget allocation)
+    // Each section is { label, content, priority } where lower priority number = truncated first
+    const sections = [
+        { label: "syncFailure", content: packet.syncFailure ?? "", priority: 6 },
+        { label: "resume", content: packet.resumeHint, priority: 5 },
+        { label: "obligations", content: packet.obligations, priority: 4 },
+        { label: "cares", content: packet.cares, priority: 3 },
+        { label: "plot", content: packet.plotLine, priority: 2 },
+        { label: "presence", content: packet.presence, priority: 1 },
+    ].filter((s) => s.content.length > 0);
+    if (sections.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.start_of_turn_packet_rendered",
+            message: "start-of-turn packet rendered: empty",
+            meta: { tokens: 0, tempo: packet.tempo },
+        });
+        return "";
+    }
+    // Build the rendered output, truncating lower-priority sections first
+    let rendered = formatSections(sections);
+    let tokens = estimateTokens(rendered);
+    // Truncate sections from lowest priority until we fit budget
+    const sortedByPriority = [...sections].sort((a, b) => a.priority - b.priority);
+    for (const section of sortedByPriority) {
+        if (tokens <= budget.max)
+            break;
+        // Skip resumeHint — it's PROTECTED
+        if (section.label === "resume")
+            continue;
+        // Remove this section entirely
+        const idx = sections.findIndex((s) => s.label === section.label);
+        sections.splice(idx, 1);
+        rendered = formatSections(sections);
+        tokens = estimateTokens(rendered);
+    }
+    // If still over budget after removing all non-protected sections, trim what's left
+    if (tokens > budget.max) {
+        const maxChars = budget.max * 4;
+        rendered = rendered.slice(0, maxChars);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.start_of_turn_packet_rendered",
+        message: `start-of-turn packet rendered: ${tokens} tokens`,
+        meta: { tokens, tempo: packet.tempo, sectionCount: sections.length },
+    });
+    return rendered;
+}
+function formatSections(sections) {
+    const parts = [];
+    for (const section of sections) {
+        switch (section.label) {
+            case "resume":
+                parts.push(`**Next:** ${section.content}`);
+                break;
+            case "obligations":
+                parts.push(`**Owed:**\n${section.content}`);
+                break;
+            case "cares":
+                parts.push(`**Cares:**\n${section.content}`);
+                break;
+            case "plot":
+                parts.push(`**Recent:**\n${section.content}`);
+                break;
+            case "presence":
+                parts.push(`**Peers:**\n${section.content}`);
+                break;
+            case "syncFailure":
+                parts.push(`**Sync warning:** ${section.content}`);
+                break;
+        }
+    }
+    return parts.join("\n\n");
+}
+/**
+ * Ultra-compact version for coding context (max 200 tokens).
+ * Just resumeHint + top obligation + top care, single-line bullets.
+ */
+function renderCompactStartOfTurnPacket(packet) {
+    const parts = [];
+    if (packet.resumeHint) {
+        parts.push(`next: ${packet.resumeHint}`);
+    }
+    if (packet.obligations) {
+        // Just first line of obligations
+        const firstOb = packet.obligations.split("\n")[0];
+        parts.push(`owed: ${firstOb.replace(/^- /, "")}`);
+    }
+    if (packet.cares) {
+        const firstCare = packet.cares.split("\n")[0];
+        parts.push(`care: ${firstCare.replace(/^- /, "")}`);
+    }
+    const compact = parts.join(" | ");
+    // Hard cap at 200 tokens (800 chars)
+    const maxChars = 200 * 4;
+    const result = compact.length > maxChars ? compact.slice(0, maxChars) : compact;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.start_of_turn_packet_compact_rendered",
+        message: `compact start-of-turn packet: ${estimateTokens(result)} tokens`,
+        meta: { tokens: estimateTokens(result) },
+    });
+    return result;
+}

package/dist/heart/streaming.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerStreamer = exports.FinalAnswerParser = void 0;
+exports.SettleStreamer = exports.SettleParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
 exports.streamResponsesApi = streamResponsesApi;
 const runtime_1 = require("../nerves/runtime");
 // Character-level state machine that extracts the answer value from
-// `final_answer` tool call JSON arguments as they stream in.
+// `settle` tool call JSON arguments as they stream in.
 // Scans for prefix `"answer":"` or `"answer": "` in the character stream,
 // then emits text handling JSON escapes, stopping at unescaped closing `"`.
-class FinalAnswerParser {
+class SettleParser {
     // Possible prefixes to match (with and without space after colon)
     static PREFIXES = ['"answer":"', '"answer": "'];
     // Buffer of characters seen so far (pre-activation only)
@@ -29,7 +29,7 @@ class FinalAnswerParser {
             if (!this._active) {
                 this.buf += ch;
                 // Check if any prefix has been fully matched in the buffer
-                for (const prefix of FinalAnswerParser.PREFIXES) {
+                for (const prefix of SettleParser.PREFIXES) {
                     if (this.buf.endsWith(prefix)) {
                         this._active = true;
                         break;
@@ -76,21 +76,25 @@ class FinalAnswerParser {
         return out;
     }
 }
-exports.FinalAnswerParser = FinalAnswerParser;
-// Shared helper: wraps FinalAnswerParser with onClearText + onTextChunk wiring.
+exports.SettleParser = SettleParser;
+// Shared helper: wraps SettleParser with onClearText + onTextChunk wiring.
 // Used by all streaming providers (Chat Completions, Responses API, Anthropic)
-// so the eager-match streaming pattern lives in one place.
-class FinalAnswerStreamer {
-    parser = new FinalAnswerParser();
+// so the eager-match settle streaming pattern lives in one place.
+class SettleStreamer {
+    parser = new SettleParser();
     _detected = false;
     callbacks;
-    constructor(callbacks) {
+    enabled;
+    constructor(callbacks, enabled = true) {
         this.callbacks = callbacks;
+        this.enabled = enabled;
     }
     get detected() { return this._detected; }
     get streamed() { return this.parser.active; }
-    /** Mark final_answer as detected. Calls onClearText on the callbacks. */
+    /** Mark settle as detected. Calls onClearText on the callbacks. */
     activate() {
+        if (!this.enabled)
+            return;
         if (this._detected)
             return;
         this._detected = true;
@@ -98,6 +102,8 @@ class FinalAnswerStreamer {
     }
     /** Feed an argument delta through the parser. Emits text via onTextChunk. */
     processDelta(delta) {
+        if (!this.enabled)
+            return;
         if (!this._detected)
             return;
         const text = this.parser.process(delta);
@@ -105,7 +111,7 @@ class FinalAnswerStreamer {
             this.callbacks.onTextChunk(text);
     }
 }
-exports.FinalAnswerStreamer = FinalAnswerStreamer;
+exports.SettleStreamer = SettleStreamer;
 function toResponsesUserContent(content) {
     if (typeof content === "string") {
         return content;
@@ -185,7 +191,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
@@ -224,7 +233,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -238,7 +247,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -353,19 +362,19 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     toolCalls[tc.index].id = tc.id;
                 if (tc.function?.name) {
                     toolCalls[tc.index].name = tc.function.name;
-                    // Detect final_answer tool call on first name delta.
+                    // Detect settle tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !answerStreamer.detected
+                    if (tc.function.name === "settle" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
                         answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (answerStreamer.detected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
                         && Object.keys(toolCalls).length === 1) {
                         answerStreamer.processDelta(tc.function.arguments);
                     }
@@ -381,10 +390,10 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerStreamer.streamed,
+        settleStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -399,7 +408,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     let functionCallCount = 0;
     for await (const event of response) {
         if (signal?.aborted)
@@ -429,10 +438,10 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                         name: String(event.item.name),
                         arguments: "",
                     };
-                    // Detect final_answer function call -- clear any streamed noise.
+                    // Detect settle function call -- clear any streamed noise.
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
-                    if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
+                    if (String(event.item.name) === "settle" && functionCallCount === 1) {
                         answerStreamer.activate();
                     }
                 }
@@ -441,9 +450,9 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
             case "response.function_call_arguments.delta": {
                 if (currentToolCall) {
                     currentToolCall.arguments += event.delta;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (answerStreamer.detected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "settle"
                         && functionCallCount === 1) {
                         answerStreamer.processDelta(String(event.delta));
                     }
@@ -485,6 +494,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerStreamer.streamed,
+        settleStreamed: answerStreamer.streamed,
     };
 }