@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/runtime/compaction/strategies/collapse.js

@@ -0,0 +1,81 @@
+/**
+ * strategies/collapse.ts
+ *
+ * Collapse strategy — full context collapse into a single compacted summary
+ * message. This is the most aggressive strategy, used when token pressure
+ * exceeds 85% or when manually triggered.
+ *
+ * All messages are reduced to a structured handoff that preserves:
+ * - The original task context (if known)
+ * - Key decisions and outcomes
+ * - The most recent user/assistant exchange
+ */
+import { estimateTokens } from '../../../core/compaction-types.js';
+/**
+ * Applies the collapse strategy: reduces all messages to a single structured
+ * handoff message that preserves the essential session context.
+ *
+ * @param input - Strategy input containing messages and context.
+ * @returns Strategy output with a single collapsed message.
+ */
+export function runCollapse(input) {
+    const startMs = Date.now();
+    const { messages, tokensBefore, sessionId, strategy } = input;
+    const warnings = [];
+    // Extract the last user/assistant exchange to preserve conversational context
+    const lastUserMsg = messages.findLast((m) => m.role === 'user');
+    const lastAssistantMsg = messages.findLast((m) => m.role === 'assistant');
+    const recentExchange = [];
+    if (lastUserMsg) {
+        const text = extractText(lastUserMsg);
+        if (text)
+            recentExchange.push(`User: ${text.slice(0, 500)}`);
+    }
+    if (lastAssistantMsg) {
+        const text = extractText(lastAssistantMsg);
+        if (text)
+            recentExchange.push(`Assistant: ${text.slice(0, 500)}`);
+    }
+    const handoffLines = [
+        `[Session Collapse — ${new Date().toISOString()}]`,
+        `Session: ${sessionId}`,
+        `${messages.length} message(s) collapsed to reduce context from ~${tokensBefore} tokens.`,
+        '',
+        '## Most Recent Exchange',
+        recentExchange.length > 0
+            ? recentExchange.join('\n')
+            : '(no user/assistant exchange found)',
+        '',
+        '## Context Note',
+        'The full conversation history has been collapsed. Please resume from the above context.',
+    ];
+    const handoff = {
+        role: 'user',
+        content: [{ type: 'text', text: handoffLines.join('\n') }],
+    };
+    const compacted = [handoff];
+    const tokensAfter = estimateTokens(JSON.stringify(compacted));
+    if (tokensAfter >= tokensBefore) {
+        warnings.push('collapse: compacted output is not smaller than input; possible data issue');
+    }
+    return {
+        messages: compacted,
+        tokensAfter,
+        summary: `Collapse: ${messages.length} messages → 1 handoff message (~${tokensAfter} tokens).`,
+        strategy,
+        durationMs: Date.now() - startMs,
+        warnings,
+    };
+}
+/** Extracts plain text from a ProviderMessage. */
+function extractText(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join(' ');
+    }
+    return '';
+}

package/dist/_internal/platform/runtime/compaction/strategies/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * strategies/index.ts
+ *
+ * Barrel re-export for all compaction strategy modules.
+ */
+export { runMicrocompact } from './microcompact.js';
+export { runCollapse } from './collapse.js';
+export { runAutocompact } from './autocompact.js';
+export { runReactive } from './reactive.js';
+export { createBoundaryCommit, validateBoundaryCommit } from './boundary-commit.js';
+export type { BoundaryCommitOptions } from './boundary-commit.js';
+export { computeQualityScore, describeScore, escalateStrategy, LOW_QUALITY_THRESHOLD, } from '../quality-score.js';
+export type { CompactionQualityScore, CompactionQualityGrade, SemanticRetentionSignals, } from '../quality-score.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/compaction/strategies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/compaction/strategies/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACpF,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC"}

package/dist/_internal/platform/runtime/compaction/strategies/index.js

@@ -0,0 +1,11 @@
+/**
+ * strategies/index.ts
+ *
+ * Barrel re-export for all compaction strategy modules.
+ */
+export { runMicrocompact } from './microcompact.js';
+export { runCollapse } from './collapse.js';
+export { runAutocompact } from './autocompact.js';
+export { runReactive } from './reactive.js';
+export { createBoundaryCommit, validateBoundaryCommit } from './boundary-commit.js';
+export { computeQualityScore, describeScore, escalateStrategy, LOW_QUALITY_THRESHOLD, } from '../quality-score.js';

package/dist/_internal/platform/runtime/compaction/strategies/microcompact.d.ts

@@ -0,0 +1,20 @@
+/**
+ * strategies/microcompact.ts
+ *
+ * Micro-compaction strategy — lightweight token reduction by summarising only
+ * the oldest turns in the conversation, preserving recent messages intact.
+ *
+ * This is the lowest-latency strategy: no LLM call, purely structural.
+ * It drops assistant/tool messages beyond a configurable "keep recent" window
+ * and prepends a short handoff note summarising what was dropped.
+ */
+import type { StrategyInput, StrategyOutput } from '../types.js';
+/**
+ * Applies micro-compaction: keep the last N messages, drop earlier ones,
+ * and prepend a brief handoff note.
+ *
+ * @param input - Strategy input containing messages and context.
+ * @returns Strategy output with compacted messages and token estimates.
+ */
+export declare function runMicrocompact(input: StrategyInput): StrategyOutput;
+//# sourceMappingURL=microcompact.d.ts.map

package/dist/_internal/platform/runtime/compaction/strategies/microcompact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microcompact.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/compaction/strategies/microcompact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKjE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAgDpE"}

package/dist/_internal/platform/runtime/compaction/strategies/microcompact.js

@@ -0,0 +1,63 @@
+/**
+ * strategies/microcompact.ts
+ *
+ * Micro-compaction strategy — lightweight token reduction by summarising only
+ * the oldest turns in the conversation, preserving recent messages intact.
+ *
+ * This is the lowest-latency strategy: no LLM call, purely structural.
+ * It drops assistant/tool messages beyond a configurable "keep recent" window
+ * and prepends a short handoff note summarising what was dropped.
+ */
+import { estimateTokens } from '../../../core/compaction-types.js';
+/** Number of recent messages preserved without modification. */
+const DEFAULT_KEEP_RECENT = 20;
+/**
+ * Applies micro-compaction: keep the last N messages, drop earlier ones,
+ * and prepend a brief handoff note.
+ *
+ * @param input - Strategy input containing messages and context.
+ * @returns Strategy output with compacted messages and token estimates.
+ */
+export function runMicrocompact(input) {
+    const startMs = Date.now();
+    const { messages, tokensBefore, strategy } = input;
+    const keepRecent = DEFAULT_KEEP_RECENT;
+    const warnings = [];
+    if (messages.length <= keepRecent) {
+        // Nothing to compact — return messages unchanged
+        warnings.push('microcompact: message count within keep window; no reduction applied');
+        return {
+            messages: [...messages],
+            tokensAfter: tokensBefore,
+            summary: 'No compaction applied — message count within keep window.',
+            strategy,
+            durationMs: Date.now() - startMs,
+            warnings,
+        };
+    }
+    const kept = messages.slice(-keepRecent);
+    const droppedCount = messages.length - keepRecent;
+    const handoff = {
+        role: 'user',
+        content: [
+            {
+                type: 'text',
+                text: [
+                    `[Session Micro-Compaction]`,
+                    `${droppedCount} earlier message(s) were summarised to reduce context size.`,
+                    `The conversation continues from the most recent ${keepRecent} messages.`,
+                ].join('\n'),
+            },
+        ],
+    };
+    const compacted = [handoff, ...kept];
+    const tokensAfter = estimateTokens(JSON.stringify(compacted));
+    return {
+        messages: compacted,
+        tokensAfter,
+        summary: `Micro-compaction: dropped ${droppedCount} messages, kept ${keepRecent} recent.`,
+        strategy,
+        durationMs: Date.now() - startMs,
+        warnings,
+    };
+}

package/dist/_internal/platform/runtime/compaction/strategies/reactive.d.ts

@@ -0,0 +1,25 @@
+/**
+ * strategies/reactive.ts
+ *
+ * Reactive compaction strategy — emergency compaction triggered when the
+ * provider returns a prompt-too-long error.
+ *
+ * This strategy must shrink the context aggressively and immediately, with
+ * minimal latency. It uses a fixed-percentage drop that guarantees the
+ * compacted context fits within a conservative safety margin (50% of the
+ * context window).
+ */
+import type { StrategyInput, StrategyOutput } from '../types.js';
+/**
+ * Applies reactive compaction to handle a prompt-too-long error.
+ *
+ * Drops messages from the oldest end until the estimated token count
+ * falls below `contextWindow * REACTIVE_TARGET_FRACTION`, then prepends
+ * a reactive handoff note.
+ *
+ * @param input - Strategy input. `input.meta.limit` may carry the provider's
+ *               reported token limit for logging purposes.
+ * @returns Strategy output with a drastically reduced message list.
+ */
+export declare function runReactive(input: StrategyInput): StrategyOutput;
+//# sourceMappingURL=reactive.d.ts.map

package/dist/_internal/platform/runtime/compaction/strategies/reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/compaction/strategies/reactive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQjE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAuDhE"}

package/dist/_internal/platform/runtime/compaction/strategies/reactive.js

@@ -0,0 +1,71 @@
+/**
+ * strategies/reactive.ts
+ *
+ * Reactive compaction strategy — emergency compaction triggered when the
+ * provider returns a prompt-too-long error.
+ *
+ * This strategy must shrink the context aggressively and immediately, with
+ * minimal latency. It uses a fixed-percentage drop that guarantees the
+ * compacted context fits within a conservative safety margin (50% of the
+ * context window).
+ */
+import { estimateTokens } from '../../../core/compaction-types.js';
+/**
+ * Target fraction of context window to fill after reactive compaction.
+ * Keeping below 50% provides a comfortable buffer for the next turn.
+ */
+const REACTIVE_TARGET_FRACTION = 0.45;
+/**
+ * Applies reactive compaction to handle a prompt-too-long error.
+ *
+ * Drops messages from the oldest end until the estimated token count
+ * falls below `contextWindow * REACTIVE_TARGET_FRACTION`, then prepends
+ * a reactive handoff note.
+ *
+ * @param input - Strategy input. `input.meta.limit` may carry the provider's
+ *               reported token limit for logging purposes.
+ * @returns Strategy output with a drastically reduced message list.
+ */
+export function runReactive(input) {
+    const startMs = Date.now();
+    const { messages, tokensBefore, contextWindow, strategy, meta } = input;
+    const warnings = [];
+    const targetTokens = Math.floor(contextWindow * REACTIVE_TARGET_FRACTION);
+    const providerLimit = typeof meta?.['limit'] === 'number' ? meta['limit'] : null;
+    // Pre-compute per-message token estimates, then use a running sum (O(n) not O(n²))
+    const perMessageTokens = messages.map((m) => estimateTokens(JSON.stringify(m)));
+    let totalTokens = perMessageTokens.reduce((a, b) => a + b, 0);
+    let cutIndex = 0;
+    while (cutIndex < messages.length - 1 && totalTokens > targetTokens) {
+        totalTokens -= perMessageTokens[cutIndex];
+        cutIndex++;
+    }
+    const remaining = messages.slice(cutIndex);
+    const droppedCount = messages.length - remaining.length;
+    if (droppedCount === 0) {
+        warnings.push('reactive: could not reduce context below target; context may still exceed limit');
+    }
+    const handoffLines = [
+        '[Reactive Compaction — Context Overflow Recovery]',
+        `Provider returned prompt-too-long${providerLimit !== null ? ` (limit: ${providerLimit} tokens)` : ''}.`,
+        `${droppedCount} message(s) dropped to recover from overflow.`,
+        `Estimated tokens before: ${tokensBefore}, target: ≤${targetTokens}.`,
+    ];
+    const handoff = {
+        role: 'user',
+        content: [{ type: 'text', text: handoffLines.join('\n') }],
+    };
+    const compacted = [handoff, ...remaining];
+    const tokensAfter = estimateTokens(JSON.stringify(compacted));
+    if (tokensAfter > targetTokens) {
+        warnings.push(`reactive: final token estimate (${tokensAfter}) still exceeds target (${targetTokens})`);
+    }
+    return {
+        messages: compacted,
+        tokensAfter,
+        summary: `Reactive compaction: dropped ${droppedCount} messages to recover from overflow (~${tokensAfter} tokens remaining).`,
+        strategy,
+        durationMs: Date.now() - startMs,
+        warnings,
+    };
+}

package/dist/_internal/platform/runtime/compaction/types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * types.ts
+ *
+ * Core types for the session compaction lifecycle engine.
+ *
+ * These are distinct from `src/core/compaction-types.ts` (the prompt compaction
+ * section types). This module defines the *lifecycle* layer: state machine
+ * states, strategies, boundary commits, and repair records.
+ */
+import type { ProviderMessage } from '../../providers/interface.js';
+import type { CompactionQualityScore } from './quality-score.js';
+export type { CompactionQualityScore };
+/**
+ * All states of the compaction lifecycle state machine.
+ *
+ * Transition map:
+ *   idle → checking_threshold
+ *   checking_threshold → microcompact | collapse | autocompact | reactive_compact | done
+ *   microcompact → boundary_commit | failed
+ *   collapse → boundary_commit | failed
+ *   autocompact → boundary_commit | failed
+ *   reactive_compact → boundary_commit | failed
+ *   boundary_commit → done | failed
+ *   done → idle
+ *   failed → idle
+ */
+export type CompactionLifecycleState = 'idle' | 'checking_threshold' | 'microcompact' | 'collapse' | 'autocompact' | 'reactive_compact' | 'boundary_commit' | 'done' | 'failed';
+/**
+ * Discriminated union identifying which compaction strategy to apply.
+ *
+ * - `microcompact`  — lightweight summary of recent turns; lowest latency
+ * - `collapse`      — full context collapse into a single summary message
+ * - `autocompact`   — threshold-based automatic compaction
+ * - `reactive`      — emergency compaction triggered by prompt-too-long errors
+ */
+export type CompactionStrategy = 'microcompact' | 'collapse' | 'autocompact' | 'reactive';
+/** Input passed to every compaction strategy. */
+export interface StrategyInput {
+    /** Session ID for event correlation. */
+    sessionId: string;
+    /** Messages at the time compaction is triggered. */
+    messages: readonly ProviderMessage[];
+    /** Estimated token count before compaction. */
+    tokensBefore: number;
+    /** Context window size for the current model. */
+    contextWindow: number;
+    /** Which strategy is being applied (for self-identification in results). */
+    strategy: CompactionStrategy;
+    /** Optional additional metadata from the trigger. */
+    meta?: Record<string, unknown>;
+}
+/** Output produced by every compaction strategy. */
+export interface StrategyOutput {
+    /** Compacted message list to replace the current conversation. */
+    messages: ProviderMessage[];
+    /** Estimated token count after compaction. */
+    tokensAfter: number;
+    /** Human-readable summary of what was compacted. */
+    summary: string;
+    /** Strategy that produced this output. */
+    strategy: CompactionStrategy;
+    /** Wall-clock duration for this strategy's execution. */
+    durationMs: number;
+    /** Any warnings or non-fatal issues encountered. */
+    warnings: string[];
+}
+/**
+ * A boundary commit persists a compacted snapshot for replay-safe resumption.
+ *
+ * Each boundary commit stores:
+ * - A unique checkpoint ID
+ * - The compacted message slice (replay-safe: can be sliced from any prior state)
+ * - A lineage reference to its parent (or null for the root commit)
+ * - The strategy that produced this checkpoint
+ */
+export interface BoundaryCommit {
+    /** Unique monotonic checkpoint identifier (e.g. `cpt_<ulid>`). */
+    checkpointId: string;
+    /** Session ID this commit belongs to. */
+    sessionId: string;
+    /** Unix timestamp (ms) when this commit was created. */
+    createdAt: number;
+    /** Strategy that produced the compacted snapshot. */
+    strategy: CompactionStrategy;
+    /**
+     * Parent checkpoint ID in the lineage chain.
+     * `null` for the root commit (no prior compaction).
+     */
+    parentCheckpointId: string | null;
+    /**
+     * Ordered lineage of all prior checkpoint IDs from root to this commit.
+     * Used for replay-safe slicing — always append-only.
+     */
+    lineage: readonly string[];
+    /** The compacted messages at this boundary. */
+    messages: readonly ProviderMessage[];
+    /** Token count of the compacted messages. */
+    tokenCount: number;
+    /** Estimated token count before compaction (for audit). */
+    tokensBefore: number;
+    /** Human-readable summary stored with this checkpoint. */
+    summary: string;
+}
+/**
+ * Result produced at the end of a complete compaction lifecycle run.
+ *
+ * Populated after transitioning through boundary_commit → done.
+ */
+export interface CompactionLifecycleResult {
+    /** Session ID this run was executed for. */
+    sessionId: string;
+    /** Strategy that was selected and executed. */
+    strategy: CompactionStrategy;
+    /** Tokens before compaction. */
+    tokensBefore: number;
+    /** Tokens after compaction. */
+    tokensAfter: number;
+    /** Total wall-clock duration from trigger to done. */
+    durationMs: number;
+    /** Boundary commit produced during this run (null if boundary_commit was skipped). */
+    commit: BoundaryCommit | null;
+    /** Compacted message list. */
+    messages: ProviderMessage[];
+    /** Strategy output warnings. */
+    warnings: string[];
+    /** Quality score for the strategy run (null when scoring was skipped). */
+    qualityScore: CompactionQualityScore | null;
+    /** Strategy switch reason if auto-escalation occurred (null otherwise). */
+    strategySwitchReason: string | null;
+}
+/**
+ * What initiated the compaction lifecycle run.
+ *
+ * - `auto`        — threshold check determined compaction is needed
+ * - `manual`      — user or orchestrator explicitly requested compaction
+ * - `prompt_too_long` — reactive trigger from a provider prompt-too-long error
+ */
+export type CompactionTrigger = 'auto' | 'manual' | 'prompt_too_long';
+/**
+ * Severity of a repair action applied during session resume.
+ */
+export type RepairSeverity = 'info' | 'warn' | 'error';
+/** A single repair action applied during session resume. */
+export interface RepairAction {
+    /** Short identifier for this repair type (e.g. `'truncate_overflow'`). */
+    kind: string;
+    /** Human-readable description of what was repaired. */
+    description: string;
+    /** Severity classification. */
+    severity: RepairSeverity;
+    /** Optional metadata about what was changed. */
+    meta?: Record<string, unknown>;
+}
+/** Result of the session resume repair pipeline. */
+export interface ResumeRepairResult {
+    /** Session ID that was repaired. */
+    sessionId: string;
+    /** Whether any repairs were applied. */
+    repaired: boolean;
+    /** List of repair actions applied (empty if no repairs were needed). */
+    actions: RepairAction[];
+    /** Messages after repair (may be unchanged if no repairs were needed). */
+    messages: ProviderMessage[];
+    /** Whether the session is safe to resume after repair. */
+    safeToResume: boolean;
+    /** Human-readable reason if not safe to resume. */
+    failReason?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/runtime/compaction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/compaction/types.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/runtime/compaction/types.js

@@ -0,0 +1,10 @@
+/**
+ * types.ts
+ *
+ * Core types for the session compaction lifecycle engine.
+ *
+ * These are distinct from `src/core/compaction-types.ts` (the prompt compaction
+ * section types). This module defines the *lifecycle* layer: state machine
+ * states, strategies, boundary commits, and repair records.
+ */
+export {};