veryfront 0.1.286 → 0.1.288

package/esm/src/chat/message-prep.js

@@ -0,0 +1,492 @@
+import { getStringField, isReasoningPart, isToolCallPart, isToolResultPart, } from "./conversation.js";
+const CHARS_PER_TOKEN = 4;
+export function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value ?? "").length / CHARS_PER_TOKEN);
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return `${text.slice(0, maxLen)}…`;
+}
+export function compressTurn(messages, startIdx, endIdx) {
+    let userQuery = "";
+    const toolNames = [];
+    let assistantConclusion = "";
+    for (let i = startIdx; i <= endIdx; i++) {
+        const msg = messages[i];
+        if (msg.role === "user") {
+            const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+            userQuery = truncate(text, 100);
+        }
+        else if (msg.role === "assistant" && Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if (part.type === "tool-call") {
+                    toolNames.push(part.toolName);
+                }
+                else if (part.type === "text") {
+                    assistantConclusion = truncate(part.text, 150);
+                }
+            }
+        }
+        else if (msg.role === "assistant" && typeof msg.content === "string") {
+            assistantConclusion = truncate(msg.content, 150);
+        }
+    }
+    const toolSummary = toolNames.length > 0 ? ` → used ${toolNames.join(", ")}` : "";
+    const conclusionSummary = assistantConclusion ? ` → ${assistantConclusion}` : "";
+    const summary = `[Compressed: ${userQuery}${toolSummary}${conclusionSummary}]`;
+    return [
+        { role: "user", content: summary },
+        { role: "assistant", content: "Acknowledged." },
+    ];
+}
+function collectTurns(messages) {
+    const turns = [];
+    let currentTurn = null;
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === "user") {
+            if (currentTurn) {
+                currentTurn.endIdx = i - 1;
+                turns.push(currentTurn);
+            }
+            currentTurn = { startIdx: i, endIdx: i, tokens: estimateTokens(messages[i].content) };
+        }
+        else if (currentTurn) {
+            currentTurn.endIdx = i;
+            currentTurn.tokens += estimateTokens(messages[i].content);
+        }
+    }
+    if (currentTurn) {
+        currentTurn.endIdx = messages.length - 1;
+        turns.push(currentTurn);
+    }
+    return turns;
+}
+export function enforceTokenBudgetWithTurnCompression(messages, budget, overhead) {
+    const effectiveBudget = budget - overhead;
+    let totalTokens = messages.reduce((sum, message) => sum + estimateTokens(message.content), 0);
+    if (totalTokens <= effectiveBudget)
+        return messages;
+    const turns = collectTurns(messages);
+    const minKeep = Math.min(2, turns.length);
+    const result = [...messages];
+    let compressCount = 0;
+    while (totalTokens > effectiveBudget && compressCount < turns.length - minKeep) {
+        const turn = turns[compressCount];
+        if (turn.compressed) {
+            compressCount++;
+            continue;
+        }
+        const compressed = compressTurn(messages, turn.startIdx, turn.endIdx);
+        const compressedTokens = compressed.reduce((sum, message) => sum + estimateTokens(message.content), 0);
+        const saved = turn.tokens - compressedTokens;
+        if (saved <= 0) {
+            compressCount++;
+            continue;
+        }
+        const turnLength = turn.endIdx - turn.startIdx + 1;
+        result.splice(turn.startIdx, turnLength, ...compressed);
+        const indexShift = compressed.length - turnLength;
+        for (let j = compressCount + 1; j < turns.length; j++) {
+            turns[j].startIdx += indexShift;
+            turns[j].endIdx += indexShift;
+        }
+        turn.endIdx = turn.startIdx + compressed.length - 1;
+        turn.tokens = compressedTokens;
+        turn.compressed = true;
+        totalTokens -= saved;
+        compressCount++;
+    }
+    if (totalTokens <= effectiveBudget)
+        return result;
+    const finalTurns = collectTurns(result);
+    const finalMinKeep = Math.min(2, finalTurns.length);
+    let dropCount = 0;
+    while (totalTokens > effectiveBudget && dropCount < finalTurns.length - finalMinKeep) {
+        totalTokens -= finalTurns[dropCount].tokens;
+        dropCount++;
+    }
+    if (dropCount === 0)
+        return result;
+    const firstKeepIdx = finalTurns[dropCount].startIdx;
+    return result.slice(firstKeepIdx);
+}
+const BUDGET_RATIO = 0.85;
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_TOKEN_BUDGET = Math.floor(DEFAULT_CONTEXT_WINDOW * BUDGET_RATIO);
+const TOKENS_PER_TOOL = 250;
+const MASK_THRESHOLD = 500;
+function serializedLength(value) {
+    return JSON.stringify(value ?? "").length;
+}
+function tryParseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildToolCallMap(messages) {
+    const map = new Map();
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            continue;
+        for (const part of msg.content) {
+            if (isToolCallPart(part)) {
+                map.set(part.toolCallId, { toolName: part.toolName, input: part.input });
+            }
+        }
+    }
+    return map;
+}
+function maskReadFile(input, charCount) {
+    const path = getStringField(input, "path", "unknown");
+    return `[File read: ${path} — content omitted (${charCount} chars)]`;
+}
+function maskBash(input, output, charCount) {
+    const cmd = truncate(getStringField(input, "command", "unknown"), 80);
+    let exitCode = "?";
+    const parsed = tryParseJson(output);
+    if (isRecord(parsed) && "exitCode" in parsed) {
+        exitCode = String(parsed.exitCode);
+    }
+    return `[Command: ${cmd} — exit ${exitCode}, output omitted (${charCount} chars)]`;
+}
+function maskWebSearch(output) {
+    const parsed = tryParseJson(output);
+    if (!Array.isArray(parsed))
+        return output;
+    return parsed.map((item) => {
+        if (!isRecord(item))
+            return item;
+        const { encryptedContent: _, ...rest } = item;
+        return rest;
+    });
+}
+function maskWebFetch(input, charCount) {
+    const url = getStringField(input, "url", "unknown");
+    return `[Fetched: ${url} — content omitted (${charCount} chars)]`;
+}
+function maskTask(output, charCount) {
+    const parsed = tryParseJson(output);
+    if (!isRecord(parsed)) {
+        return `[task output omitted (${charCount} chars)]`;
+    }
+    const masked = {};
+    if ("success" in parsed)
+        masked.success = parsed.success;
+    if ("description" in parsed)
+        masked.description = parsed.description;
+    if ("result" in parsed) {
+        masked.result = typeof parsed.result === "string"
+            ? truncate(parsed.result, 500)
+            : parsed.result;
+    }
+    return masked;
+}
+function maskGeneric(toolName, charCount) {
+    return `[${toolName} output omitted (${charCount} chars)]`;
+}
+function getOutputValue(output) {
+    if (!isRecord(output))
+        return output;
+    if ((output.type === "text" || output.type === "json") && "value" in output) {
+        return output.value;
+    }
+    return output;
+}
+function wrapToolResultOutput(original, newValue) {
+    const textValue = typeof newValue === "string" ? newValue : JSON.stringify(newValue);
+    if (original.type === "text") {
+        return { ...original, value: textValue };
+    }
+    if (original.type === "json") {
+        return { type: "text", value: textValue };
+    }
+    return original;
+}
+export function maskOldToolOutputs(messages) {
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    if (lastUserIdx <= 0)
+        return messages;
+    const toolCallMap = buildToolCallMap(messages);
+    return messages.map((msg, idx) => {
+        if (idx >= lastUserIdx)
+            return msg;
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+            const filtered = msg.content.filter((part) => !isReasoningPart(part));
+            if (filtered.length !== msg.content.length) {
+                return { ...msg, content: filtered };
+            }
+            return msg;
+        }
+        if (msg.role !== "tool" || !Array.isArray(msg.content))
+            return msg;
+        const newContent = msg.content.map((part) => {
+            if (part.type !== "tool-result") {
+                return part;
+            }
+            const rawValue = getOutputValue(part.output);
+            const charCount = serializedLength(rawValue);
+            if (charCount < MASK_THRESHOLD)
+                return part;
+            const callInfo = toolCallMap.get(part.toolCallId);
+            const toolName = part.toolName || callInfo?.toolName || "unknown";
+            const input = callInfo?.input;
+            let masked;
+            switch (toolName) {
+                case "readFile":
+                case "get_file":
+                    masked = maskReadFile(input, charCount);
+                    break;
+                case "bash":
+                    masked = maskBash(input, rawValue, charCount);
+                    break;
+                case "web_search":
+                    masked = maskWebSearch(rawValue);
+                    break;
+                case "web_fetch":
+                    masked = maskWebFetch(input, charCount);
+                    break;
+                case "task":
+                    masked = maskTask(rawValue, charCount);
+                    break;
+                default:
+                    masked = maskGeneric(toolName, charCount);
+                    break;
+            }
+            return { ...part, output: wrapToolResultOutput(part.output, masked) };
+        });
+        return { ...msg, content: newContent };
+    });
+}
+function createSyntheticToolResult(toolCallId, toolName) {
+    return {
+        type: "tool-result",
+        toolCallId,
+        toolName,
+        output: { type: "text", value: "[tool result unavailable]" },
+    };
+}
+export function repairToolPairs(messages) {
+    const result = [...messages];
+    let mutated = false;
+    for (let index = 0; index < result.length; index++) {
+        const message = result[index];
+        if (message.role !== "assistant" || !Array.isArray(message.content)) {
+            continue;
+        }
+        const inlineResultIds = new Set();
+        for (const part of message.content) {
+            if (isToolResultPart(part)) {
+                inlineResultIds.add(part.toolCallId);
+            }
+        }
+        const repairedContent = [];
+        const regularToolCalls = [];
+        for (const part of message.content) {
+            repairedContent.push(part);
+            if (!isToolCallPart(part)) {
+                continue;
+            }
+            const toolName = part.toolName ?? "unknown";
+            if (part.providerExecuted) {
+                if (!inlineResultIds.has(part.toolCallId)) {
+                    repairedContent.push(createSyntheticToolResult(part.toolCallId, toolName));
+                    mutated = true;
+                }
+                continue;
+            }
+            if (!inlineResultIds.has(part.toolCallId)) {
+                regularToolCalls.push({ id: part.toolCallId, toolName });
+            }
+        }
+        if (repairedContent.length !== message.content.length) {
+            result[index] = {
+                ...message,
+                content: repairedContent,
+            };
+        }
+        if (regularToolCalls.length === 0) {
+            continue;
+        }
+        const nextMessage = result[index + 1];
+        const immediateResultIds = new Set();
+        if (nextMessage?.role === "tool" && Array.isArray(nextMessage.content)) {
+            for (const part of nextMessage.content) {
+                if (isToolResultPart(part)) {
+                    immediateResultIds.add(part.toolCallId);
+                }
+            }
+        }
+        const unresolvedCalls = regularToolCalls.filter((toolCall) => !immediateResultIds.has(toolCall.id));
+        if (unresolvedCalls.length === 0) {
+            continue;
+        }
+        const movedResults = new Map();
+        for (let laterIndex = index + 2; laterIndex < result.length && movedResults.size < unresolvedCalls.length; laterIndex++) {
+            const laterMessage = result[laterIndex];
+            if (laterMessage?.role !== "tool" || !Array.isArray(laterMessage.content)) {
+                continue;
+            }
+            let removedFromLater = false;
+            const keptLaterContent = laterMessage.content.filter((part) => {
+                if (!isToolResultPart(part)) {
+                    return true;
+                }
+                if (!unresolvedCalls.some((toolCall) => toolCall.id === part.toolCallId) ||
+                    movedResults.has(part.toolCallId)) {
+                    return true;
+                }
+                movedResults.set(part.toolCallId, part);
+                removedFromLater = true;
+                return false;
+            });
+            if (!removedFromLater) {
+                continue;
+            }
+            mutated = true;
+            if (keptLaterContent.length === 0) {
+                result.splice(laterIndex, 1);
+                laterIndex--;
+                continue;
+            }
+            result[laterIndex] = {
+                ...laterMessage,
+                content: keptLaterContent,
+            };
+        }
+        const repairedResults = unresolvedCalls.map((toolCall) => movedResults.get(toolCall.id) ?? createSyntheticToolResult(toolCall.id, toolCall.toolName));
+        if (nextMessage?.role === "tool" && Array.isArray(nextMessage.content)) {
+            result[index + 1] = {
+                ...nextMessage,
+                content: [...repairedResults, ...nextMessage.content],
+            };
+        }
+        else {
+            const toolMessage = {
+                role: "tool",
+                content: repairedResults,
+            };
+            result.splice(index + 1, 0, toolMessage);
+        }
+        mutated = true;
+    }
+    return mutated ? result : messages;
+}
+export function estimateOverhead(instructions, toolCount) {
+    const instructionTokens = estimateTokens(instructions);
+    return instructionTokens + toolCount * TOKENS_PER_TOOL;
+}
+export function ensureToolCallInputs(messages) {
+    let mutated = false;
+    const result = messages.map((msg) => {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            return msg;
+        let msgMutated = false;
+        const newContent = msg.content.map((part) => {
+            if (isToolCallPart(part)) {
+                const input = part.input;
+                if (input === undefined || input === null || typeof input !== "object" || Array.isArray(input)) {
+                    msgMutated = true;
+                    return { ...part, input: {} };
+                }
+            }
+            return part;
+        });
+        if (msgMutated) {
+            mutated = true;
+            return { ...msg, content: newContent };
+        }
+        return msg;
+    });
+    return mutated ? result : messages;
+}
+export function compactForStep(messages, overhead = 0) {
+    const compacted = enforceTokenBudget(maskOldToolOutputs(messages), DEFAULT_TOKEN_BUDGET, overhead);
+    let end = compacted.length;
+    while (end > 1 && compacted[end - 1].role === "assistant") {
+        end--;
+    }
+    const trimmed = end < compacted.length ? compacted.slice(0, end) : compacted;
+    return ensureToolCallInputs(repairToolPairs(dedupeToolHistory(trimmed)));
+}
+export function dedupeToolHistory(messages) {
+    const seenToolCallIds = new Set();
+    const seenToolResultIds = new Set();
+    let mutated = false;
+    const deduped = [];
+    const filterParts = (parts) => {
+        const filtered = parts.filter((part) => {
+            if (isToolCallPart(part)) {
+                if (seenToolCallIds.has(part.toolCallId)) {
+                    mutated = true;
+                    return false;
+                }
+                seenToolCallIds.add(part.toolCallId);
+                return true;
+            }
+            if (isToolResultPart(part)) {
+                if (seenToolResultIds.has(part.toolCallId)) {
+                    mutated = true;
+                    return false;
+                }
+                seenToolResultIds.add(part.toolCallId);
+                return true;
+            }
+            return true;
+        });
+        return { filtered, changed: filtered.length !== parts.length };
+    };
+    for (const message of messages) {
+        if (message.role === "user" && Array.isArray(message.content)) {
+            const { filtered, changed } = filterParts(message.content);
+            if (!changed) {
+                deduped.push(message);
+                continue;
+            }
+            if (filtered.length > 0)
+                deduped.push({ ...message, content: filtered });
+        }
+        else if (message.role === "assistant" && Array.isArray(message.content)) {
+            const { filtered, changed } = filterParts(message.content);
+            if (!changed) {
+                deduped.push(message);
+                continue;
+            }
+            if (filtered.length > 0)
+                deduped.push({ ...message, content: filtered });
+        }
+        else if (message.role === "tool") {
+            const { filtered, changed } = filterParts(message.content);
+            if (!changed) {
+                deduped.push(message);
+                continue;
+            }
+            if (filtered.length > 0)
+                deduped.push({ ...message, content: filtered });
+        }
+        else {
+            deduped.push(message);
+        }
+    }
+    return mutated ? deduped : messages;
+}
+export function enforceTokenBudget(messages, budget = DEFAULT_TOKEN_BUDGET, overhead = 0) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    return enforceTokenBudgetWithTurnCompression(messages, budget, overhead);
+}

package/esm/src/utils/version-constant.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.286";
+export declare const VERSION = "0.1.288";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.286";
+export const VERSION = "0.1.288";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.286",
+  "version": "0.1.288",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",
@@ -177,6 +177,14 @@
       "import": "./esm/cli/main.js",
       "types": "./esm/cli/main.d.ts"
     },
+    "./chat/conversation": {
+      "import": "./esm/src/chat/conversation.js",
+      "types": "./esm/src/chat/conversation.d.ts"
+    },
+    "./chat/message-prep": {
+      "import": "./esm/src/chat/message-prep.js",
+      "types": "./esm/src/chat/message-prep.d.ts"
+    },
     "./tsconfig.json": "./tsconfig.json"
   },
   "scripts": {},

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.286",
+  "version": "0.1.288",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "workspace": [
@@ -63,7 +63,9 @@ export default {
     "./embedding": "./src/embedding/index.ts",
     "./extensions": "./src/extensions/index.ts",
     "./extensions/interfaces": "./src/extensions/interfaces/index.ts",
-    "./cli": "./cli/main.ts"
+    "./cli": "./cli/main.ts",
+    "./chat/conversation": "./src/chat/conversation.ts",
+    "./chat/message-prep": "./src/chat/message-prep.ts"
   },
   "imports": {
     "veryfront/head": "./src/react/runtime/core.ts",
@@ -273,7 +275,9 @@ export default {
     "unified": "npm:unified@11.0.5",
     "vfile": "npm:vfile@6.0.3",
     "class-variance-authority": "npm:class-variance-authority@0.7.1",
-    "tailwind-merge": "npm:tailwind-merge@3.5.0"
+    "tailwind-merge": "npm:tailwind-merge@3.5.0",
+    "veryfront/chat/conversation": "./src/chat/conversation.ts",
+    "veryfront/chat/message-prep": "./src/chat/message-prep.ts"
   },
   "compilerOptions": {
     "jsx": "react-jsx",