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

package/dist/mind/prompt-budget.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS = exports.PROMPT_BUDGET_POLICY_VERSION = void 0;
+exports.estimatePromptBudgetTokensForMessage = estimatePromptBudgetTokensForMessage;
+exports.estimatePromptBudgetTokens = estimatePromptBudgetTokens;
+exports.applyPromptBudget = applyPromptBudget;
+const runtime_1 = require("../nerves/runtime");
+exports.PROMPT_BUDGET_POLICY_VERSION = "prompt-budget/v1";
+exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS = 24_000;
+function contentCharacters(content) {
+    if (typeof content === "string")
+        return content.length;
+    if (!content)
+        return 0;
+    if (Array.isArray(content)) {
+        return content.reduce((total, part) => {
+            if (typeof part === "string")
+                return total + part.length;
+            if (!part || typeof part !== "object")
+                return total;
+            const record = part;
+            if (typeof record.text === "string")
+                return total + record.text.length;
+            if (typeof record.content === "string")
+                return total + record.content.length;
+            try {
+                return total + JSON.stringify(record).length;
+            }
+            catch {
+                return total;
+            }
+        }, 0);
+    }
+    if (typeof content === "object") {
+        const record = content;
+        if (typeof record.text === "string")
+            return record.text.length;
+        if (typeof record.content === "string")
+            return record.content.length;
+        try {
+            return JSON.stringify(record).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+function toolCallCharacters(toolCalls) {
+    if (!Array.isArray(toolCalls))
+        return 0;
+    let total = 0;
+    for (const call of toolCalls) {
+        if (!call || typeof call !== "object")
+            continue;
+        const record = call;
+        if (typeof record.id === "string")
+            total += record.id.length;
+        const fn = record.function;
+        if (fn && typeof fn === "object") {
+            const fnRecord = fn;
+            if (typeof fnRecord.name === "string")
+                total += fnRecord.name.length;
+            if (typeof fnRecord.arguments === "string")
+                total += fnRecord.arguments.length;
+        }
+    }
+    return total;
+}
+function estimatePromptBudgetTokensForMessage(message) {
+    const record = message;
+    let characters = 0;
+    if (typeof record.role === "string")
+        characters += record.role.length;
+    if (typeof record.name === "string")
+        characters += record.name.length;
+    if (typeof record.tool_call_id === "string")
+        characters += record.tool_call_id.length;
+    characters += contentCharacters(record.content);
+    characters += toolCallCharacters(record.tool_calls);
+    return Math.ceil(characters / 4);
+}
+function estimatePromptBudgetTokens(messages) {
+    return messages.reduce((total, message) => total + estimatePromptBudgetTokensForMessage(message), 0);
+}
+function itemTokens(item) {
+    return estimatePromptBudgetTokens(item.messages);
+}
+function cloneMessage(message) {
+    return { ...message };
+}
+function messageText(message) {
+    return typeof message.content === "string" ? message.content : "";
+}
+function isSenseContextPacketText(text) {
+    return /^Untrusted\s+\S+\s+context for this same thread\./.test(text);
+}
+function sourceRefsFrom(text) {
+    return [...new Set(text.match(/\bbbmsg:[^\]\s,]+/g) ?? [])];
+}
+function compactSenseContextItem(item) {
+    const message = item.messages[0];
+    const text = messageText(message);
+    const firstLine = text.split("\n").find((line) => line.trim().length > 0);
+    const refs = sourceRefsFrom(text);
+    const content = [
+        firstLine,
+        `[prompt budget compacted message excerpts; source refs retained: ${refs.length > 0 ? refs.join(", ") : "none"}]`,
+    ].join("\n");
+    return {
+        ...item,
+        compacted: true,
+        messages: [{ ...cloneMessage(message), content }],
+    };
+}
+const SYSTEM_MARKERS = [
+    { marker: "## from my kept record", source: "kept-memory", priority: 5 },
+    { marker: "## retrieved from my Desk record diary", source: "kept-memory", priority: 5 },
+    { marker: "## habit receipt", source: "habit-receipt", priority: 6 },
+    { marker: "## run ledger", source: "habit-receipt", priority: 6 },
+    { marker: "## diagnostics", source: "diagnostics", priority: 7 },
+    { marker: "## doctor", source: "diagnostics", priority: 7 },
+    { marker: "## incident bundle", source: "diagnostics", priority: 7 },
+    { marker: "## replay", source: "diagnostics", priority: 7 },
+];
+function classifySystemSegment(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("habit receipt") || lower.includes("run ledger"))
+        return { source: "habit-receipt", priority: 6 };
+    if (lower.includes("diagnostics") || lower.includes("doctor") || lower.includes("incident bundle") || lower.includes("replay")) {
+        return { source: "diagnostics", priority: 7 };
+    }
+    return { source: "system-prompt", priority: 1 };
+}
+function systemItems(message, index) {
+    const text = messageText(message);
+    if (isSenseContextPacketText(text)) {
+        return [{
+                id: `system:${index}:context`,
+                priority: 4,
+                source: "sense-context-packet",
+                messages: [cloneMessage(message)],
+                originalMessageCount: 1,
+            }];
+    }
+    const markerPositions = SYSTEM_MARKERS
+        .map((marker) => ({ ...marker, start: text.toLowerCase().indexOf(marker.marker.toLowerCase()) }))
+        .filter((entry) => entry.start >= 0)
+        .sort((left, right) => left.start - right.start);
+    if (markerPositions.length === 0) {
+        const classified = classifySystemSegment(text);
+        return [{
+                id: `system:${index}:0`,
+                priority: classified.priority,
+                source: classified.source,
+                messages: [cloneMessage(message)],
+                originalMessageCount: 1,
+            }];
+    }
+    const segments = [];
+    if (markerPositions[0].start > 0) {
+        segments.push({ start: 0, end: markerPositions[0].start, source: "system-prompt", priority: 1 });
+    }
+    markerPositions.forEach((position, markerIndex) => {
+        segments.push({
+            start: position.start,
+            end: markerPositions[markerIndex + 1]?.start ?? text.length,
+            source: position.source,
+            priority: position.priority,
+        });
+    });
+    return segments
+        .map((segment, segmentIndex) => {
+        const content = text.slice(segment.start, segment.end).trim();
+        if (!content)
+            return null;
+        return {
+            id: `system:${index}:${segmentIndex}`,
+            priority: segment.priority,
+            source: segment.source,
+            messages: [{ ...cloneMessage(message), content }],
+            originalMessageCount: segmentIndex === 0 ? 1 : 0,
+        };
+    })
+        .filter((item) => item !== null);
+}
+function assistantHasToolCalls(message) {
+    return message.role === "assistant"
+        && Array.isArray(message.tool_calls)
+        && message.tool_calls.length > 0;
+}
+function nonSystemSourceFor(messages) {
+    const text = messages.map(messageText).join("\n").toLowerCase();
+    if (text.includes("habit receipt") || text.includes("run ledger"))
+        return "habit-receipt";
+    if (text.includes("diagnostics") || text.includes("doctor") || text.includes("incident bundle") || text.includes("replay"))
+        return "diagnostics";
+    return "recent-session-tail";
+}
+function buildPromptBudgetItems(messages) {
+    const rawItems = [];
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (message.role === "system") {
+            rawItems.push(...systemItems(message, index));
+            index += 1;
+            continue;
+        }
+        if (assistantHasToolCalls(message)) {
+            const block = [cloneMessage(message)];
+            let next = index + 1;
+            while (messages[next]?.role === "tool") {
+                block.push(cloneMessage(messages[next]));
+                next += 1;
+            }
+            rawItems.push({
+                id: `conversation:${index}`,
+                priority: 3,
+                source: nonSystemSourceFor(block),
+                messages: block,
+                originalMessageCount: block.length,
+            });
+            index = next;
+            continue;
+        }
+        rawItems.push({
+            id: `conversation:${index}`,
+            priority: 3,
+            source: nonSystemSourceFor([message]),
+            messages: [cloneMessage(message)],
+            originalMessageCount: 1,
+        });
+        index += 1;
+    }
+    const lastUserItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "user"));
+    const latestToolItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "tool" || assistantHasToolCalls(message)));
+    return rawItems.map((item, itemIndex) => {
+        if (itemIndex === lastUserItemIndex) {
+            return { ...item, priority: 1, source: "current-user-message" };
+        }
+        if (itemIndex === latestToolItemIndex) {
+            return { ...item, priority: 1, source: "active-tool-result-context" };
+        }
+        if (item.messages.every((message) => message.role === "system"))
+            return item;
+        if (item.source === "habit-receipt")
+            return { ...item, priority: 6 };
+        if (item.source === "diagnostics")
+            return { ...item, priority: 7 };
+        if (lastUserItemIndex >= 0 && itemIndex < lastUserItemIndex)
+            return { ...item, priority: 8, source: "older-session-history" };
+        return { ...item, priority: 3, source: "recent-session-tail" };
+    });
+}
+function flattenItems(items) {
+    return items.flatMap((item) => item.messages.map(cloneMessage));
+}
+function budgetFor(input) {
+    const contextWindowTokens = typeof input.contextWindowTokens === "number" && Number.isFinite(input.contextWindowTokens) && input.contextWindowTokens > 0
+        ? Math.floor(input.contextWindowTokens)
+        : exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS;
+    const outputReserveRatio = input.outputReserveRatio ?? 0.2;
+    const protocolReserveRatio = input.protocolReserveRatio ?? 0.1;
+    const outputReserveTokens = Math.floor(contextWindowTokens * outputReserveRatio);
+    const protocolReserveTokens = Math.floor(contextWindowTokens * protocolReserveRatio);
+    return {
+        provider: input.provider,
+        model: input.model,
+        contextWindowTokens,
+        outputReserveTokens,
+        protocolReserveTokens,
+        inputTokenLimit: Math.max(0, contextWindowTokens - outputReserveTokens - protocolReserveTokens),
+    };
+}
+function totalItemTokens(items) {
+    return estimatePromptBudgetTokens(flattenItems(items));
+}
+function truncationFor(item, reason, beforeTokens, afterTokens) {
+    return {
+        source: item.source,
+        reason,
+        beforeTokens,
+        afterTokens,
+        messageCount: item.originalMessageCount,
+    };
+}
+function emitPromptBudgetEvent(result) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.prompt_budget_applied",
+        message: "applied final prompt budget before provider turn",
+        meta: {
+            status: result.status,
+            provider: result.budget.provider,
+            model: result.budget.model,
+            contextWindowTokens: result.budget.contextWindowTokens,
+            inputTokenLimit: result.budget.inputTokenLimit,
+            estimatedBeforeTokens: result.stats.estimatedBeforeTokens,
+            estimatedAfterTokens: result.stats.estimatedAfterTokens,
+            droppedMessages: result.stats.droppedMessages,
+            truncationCount: result.stats.truncations.length,
+        },
+    });
+}
+function applyPromptBudget(input) {
+    const budget = budgetFor(input);
+    const estimatedBeforeTokens = estimatePromptBudgetTokens(input.messages);
+    const truncations = [];
+    let droppedMessages = 0;
+    if (estimatedBeforeTokens <= budget.inputTokenLimit) {
+        const result = {
+            policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+            status: "within_budget",
+            messages: input.messages.map(cloneMessage),
+            budget,
+            stats: {
+                estimatedBeforeTokens,
+                estimatedAfterTokens: estimatedBeforeTokens,
+                originalMessages: input.messages.length,
+                finalMessages: input.messages.length,
+                droppedMessages,
+                truncations,
+            },
+        };
+        emitPromptBudgetEvent(result);
+        return result;
+    }
+    let items = buildPromptBudgetItems(input.messages);
+    for (const priority of [8, 7, 6, 5, 4, 3]) {
+        if (totalItemTokens(items) <= budget.inputTokenLimit)
+            break;
+        if (priority === 4) {
+            items = items.map((item) => {
+                if (item.priority !== 4 || item.compacted)
+                    return item;
+                const beforeTokens = itemTokens(item);
+                const compacted = compactSenseContextItem(item);
+                const afterTokens = itemTokens(compacted);
+                if (afterTokens < beforeTokens) {
+                    truncations.push(truncationFor(item, "compacted message excerpts to source refs", beforeTokens, afterTokens));
+                }
+                return compacted;
+            });
+            if (totalItemTokens(items) <= budget.inputTokenLimit)
+                break;
+        }
+        for (let itemIndex = 0; itemIndex < items.length && totalItemTokens(items) > budget.inputTokenLimit; itemIndex += 1) {
+            const item = items[itemIndex];
+            if (item.priority !== priority)
+                continue;
+            const beforeTokens = itemTokens(item);
+            droppedMessages += item.originalMessageCount;
+            truncations.push(truncationFor(item, "dropped to fit prompt budget", beforeTokens, 0));
+            items = items.filter((_, index) => index !== itemIndex);
+            itemIndex -= 1;
+        }
+    }
+    const messages = flattenItems(items);
+    const estimatedAfterTokens = estimatePromptBudgetTokens(messages);
+    const status = estimatedAfterTokens <= budget.inputTokenLimit
+        ? "trimmed"
+        : "over_budget";
+    const result = {
+        policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+        status,
+        messages,
+        budget,
+        stats: {
+            estimatedBeforeTokens,
+            estimatedAfterTokens,
+            originalMessages: input.messages.length,
+            finalMessages: messages.length,
+            droppedMessages,
+            truncations,
+        },
+    };
+    emitPromptBudgetEvent(result);
+    return result;
+}

package/dist/mind/prompt-refresh.js

@@ -5,11 +5,12 @@ const prompt_1 = require("./prompt");
 const runtime_1 = require("../nerves/runtime");
 async function refreshSystemPrompt(messages, channel, options, context) {
     const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    const flattened = (0, prompt_1.flattenSystemPrompt)(newSystem);
     if (messages.length > 0 && messages[0].role === "system") {
-        messages[0] = { role: "system", content: newSystem };
+        messages[0] = { role: "system", content: flattened };
     }
     else {
-        messages.unshift({ role: "system", content: newSystem });
+        messages.unshift({ role: "system", content: flattened });
     }
     (0, runtime_1.emitNervesEvent)({
         event: "mind.system_prompt_refreshed",