@alisio/core 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/core/compaction.d.ts

@@ -44,6 +44,31 @@ export interface CompactionPlan {
     kept: Message[];
 }
 export declare function planCompaction(messages: Message[], options?: CompactionOptions): CompactionPlan | undefined;
+/** Marker appended to message content cut by the context-budget reduction. */
+export declare const TRUNCATION_MARKER = "\u2026 [truncated by context budget]";
+/** Default per-message cap for kept tool result text after a failed compaction. */
+export declare const MAX_TOOL_RESULT_CHARS = 8000;
+/** Default per-message cap for kept user/assistant text after a failed compaction. */
+export declare const MAX_TEXT_CHARS = 16000;
+export interface MessageReductionOptions {
+    /** Keep at most this many characters of text per tool result (default 8_000). */
+    maxToolResultChars?: number;
+    /** Keep at most this many characters per user/assistant text (default 16_000). */
+    maxTextChars?: number;
+}
+export interface MessageReduction {
+    messages: Message[];
+    /** Number of messages whose content was truncated. */
+    truncated: number;
+}
+/**
+ * Cuts oversized retained content so the session fits the context-budget hard limit after a
+ * compaction could not. Only message CONTENT changes (user/assistant `text` and the text parts
+ * of tool results); roles, call IDs, order and message boundaries stay identical, so the
+ * transcript remains valid and replayable and a tool call is never separated from its results.
+ * Checkpoint summaries (`summary: true`) are bounded by design and never truncated.
+ */
+export declare function reduceMessageSizes(messages: Message[], options?: MessageReductionOptions): MessageReduction;
 /**
  * Plain-text transcript used as summarizer input. Provider continuation data (for example
  * encrypted reasoning) is opaque and is intentionally not included.

package/dist/core/compaction.js

@@ -91,6 +91,60 @@ export function planCompaction(messages, options = {}) {
     return { cut, summarized: messages.slice(0, cut), kept: messages.slice(cut) };
 }
 const clip = (text, max) => text.length > max ? `${text.slice(0, max)}… [truncated]` : text;
+/** Marker appended to message content cut by the context-budget reduction. */
+export const TRUNCATION_MARKER = "… [truncated by context budget]";
+/** Default per-message cap for kept tool result text after a failed compaction. */
+export const MAX_TOOL_RESULT_CHARS = 8_000;
+/** Default per-message cap for kept user/assistant text after a failed compaction. */
+export const MAX_TEXT_CHARS = 16_000;
+/**
+ * Cuts oversized retained content so the session fits the context-budget hard limit after a
+ * compaction could not. Only message CONTENT changes (user/assistant `text` and the text parts
+ * of tool results); roles, call IDs, order and message boundaries stay identical, so the
+ * transcript remains valid and replayable and a tool call is never separated from its results.
+ * Checkpoint summaries (`summary: true`) are bounded by design and never truncated.
+ */
+export function reduceMessageSizes(messages, options = {}) {
+    const maxToolResultChars = options.maxToolResultChars ?? MAX_TOOL_RESULT_CHARS;
+    const maxTextChars = options.maxTextChars ?? MAX_TEXT_CHARS;
+    let truncated = 0;
+    const reduced = messages.map((m) => {
+        if (m.role === "user") {
+            if (m.summary || m.text.length <= maxTextChars)
+                return m;
+            truncated++;
+            return { ...m, text: `${m.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
+        }
+        if (m.role === "assistant") {
+            if (m.text.length <= maxTextChars)
+                return m;
+            truncated++;
+            return { ...m, text: `${m.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
+        }
+        let used = 0;
+        let changed = false;
+        const content = m.result.content.map((part) => {
+            const room = maxToolResultChars - used;
+            const text = room <= 0
+                ? TRUNCATION_MARKER
+                : part.text.length > room
+                    ? `${part.text.slice(0, room)}\n${TRUNCATION_MARKER}`
+                    : part.text;
+            if (text !== part.text) {
+                changed = true;
+                used = maxToolResultChars;
+            }
+            else
+                used += part.text.length;
+            return { type: "text", text };
+        });
+        if (!changed)
+            return m;
+        truncated++;
+        return { ...m, result: { ...m.result, content } };
+    });
+    return truncated ? { messages: reduced, truncated } : { messages, truncated: 0 };
+}
 /**
  * Plain-text transcript used as summarizer input. Provider continuation data (for example
  * encrypted reasoning) is opaque and is intentionally not included.

package/dist/core/contracts.d.ts

@@ -56,6 +56,12 @@ export interface SessionStore {
      * rest verbatim and in order. Callers must never split a tool call from its results.
      */
     compact(id: string, replaced: number, summary: Message): void;
+    /**
+     * Atomically replace the whole active history with `messages` (like `compact` without a
+     * summary): used after a context-budget reduction so the persisted transcript matches what
+     * was actually sent. Callers must never split a tool call from its results.
+     */
+    overwrite(id: string, messages: Message[]): void;
     acquire(id: string): void;
     release(id: string): void;
     beginCall(session: string, call: ToolCall): void;

package/dist/core/runner.js

@@ -1,5 +1,5 @@
 import { textResult, } from "@alisio/sdk";
-import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, shouldCompactContext, summarize, summaryMessage, } from "./compaction.js";
+import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, reduceMessageSizes, shouldCompactContext, summarize, summaryMessage, } from "./compaction.js";
 /**
  * Default cumulative token budget for one run: several context windows (each turn re-sends the
  * context), clamped; 1M tokens when the window is unknown.
@@ -263,6 +263,7 @@ export class AgentRunner {
     async run(sessionId, prompt, signal, options = {}) {
         const controller = this.claim(sessionId);
         const o = this.options, emit = this.emitter(sessionId);
+        const limit = o.maxContextChars ?? 160_000;
         let tokens = 0, lastText = "", acquired = false;
         const usageTotal = { input: 0, output: 0 };
         const timeout = AbortSignal.timeout(options.timeoutMs ?? o.timeoutMs ?? 300_000);
@@ -351,13 +352,27 @@ export class AgentRunner {
                 // estimate (`chars / 4 >= maxContextChars / 4`). `maxContextChars` below stays as the
                 // post-compaction hard limit.
                 if (compaction.auto !== false &&
-                    shouldCompactContext(used(), chars(), o.contextWindow?.(model), o.maxContextChars ?? 160_000, compaction.threshold ?? 0.85)) {
+                    shouldCompactContext(used(), chars(), o.contextWindow?.(model), limit, compaction.threshold ?? 0.85)) {
                     await this.compactLocked(sessionId, emit, model, combined, "auto");
                     instructions = await withPersona();
                     messages = o.store.messages(sessionId);
                 }
-                if (chars() > (o.maxContextChars ?? 160_000))
-                    throw new Error("Context budget exceeded and compaction could not reduce it; start a new session.");
+                // A compaction that still leaves the session over the hard limit (typically a kept tail
+                // holding huge tool outputs) is reduced in place instead of failing outright: oversized
+                // kept content is cut per message (roles/callIds/boundaries untouched, so the transcript
+                // stays valid and replayable). Only if even the reduced tail exceeds the limit the run
+                // fails with an actionable error; the reduction is persisted either way, so the session
+                // stays usable for later prompts.
+                if (chars() > limit) {
+                    const reduction = reduceMessageSizes(messages);
+                    if (reduction.truncated > 0) {
+                        o.store.overwrite(sessionId, reduction.messages);
+                        messages = reduction.messages;
+                        emit("context_reduced", { messages: reduction.truncated });
+                    }
+                    if (chars() > limit)
+                        throw new Error(`Context budget exceeded and compaction could not reduce it (approximately ${chars()} characters; limit ${limit}). Run /compact, trim large tool outputs, or start a new session.`);
+                }
                 let completion;
                 let truncated = false;
                 let usage;

package/dist/runtime/store.d.ts

@@ -25,6 +25,7 @@ export declare class SQLiteStore implements SessionStore {
     append(id: string, message: Message): void;
     setModel(id: string, model: string): void;
     compact(id: string, replaced: number, summary: Message): void;
+    overwrite(id: string, messages: Message[]): void;
     acquire(id: string): void;
     release(id: string): void;
     beginCall(id: string, call: ToolCall): void;

package/dist/runtime/store.js

@@ -168,6 +168,15 @@ export class SQLiteStore {
                 this.db.prepare("INSERT INTO messages(session,body) VALUES(?,?)").run(id, row.body);
         });
     }
+    overwrite(id, messages) {
+        this.db.transaction(() => {
+            // Retire the active rows (originals stay marked compacted for auditing), then rewrite
+            // the reduced transcript in the same order.
+            this.db.prepare("UPDATE messages SET compacted=1 WHERE session=? AND compacted=0").run(id);
+            for (const message of messages)
+                this.append(id, message);
+        });
+    }
     acquire(id) {
         this.db.transaction(() => {
             this.get(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",