@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/runtime/session-pool.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Session Pool - Claude CLI Session Reuse Manager
+ *
+ * Manages Claude CLI session IDs per channel to enable conversation continuity.
+ * Instead of creating new sessions for each message, reuses existing sessions
+ * so Claude CLI maintains its own conversation history.
+ *
+ * Benefits:
+ * - 6x token reduction (no manual history injection needed)
+ * - Natural conversation flow (Claude remembers context)
+ * - Automatic summarization by Claude when context fills up
+ */
+/**
+ * Session entry with metadata
+ */
+interface SessionEntry {
+    /** Claude CLI session ID */
+    sessionId: string;
+    /** Last activity timestamp */
+    lastActive: number;
+    /** Message count in this session */
+    messageCount: number;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Whether session is currently in use (locked) */
+    inUse: boolean;
+    /** Legacy context occupancy field; durable runtimes own compaction, so this stays zero */
+    totalInputTokens: number;
+}
+/**
+ * Session Pool configuration
+ */
+export interface SessionPoolConfig {
+    /** Session timeout in milliseconds (default: 30 minutes) */
+    sessionTimeoutMs?: number;
+    /** Maximum sessions to keep in pool (default: 100) */
+    maxSessions?: number;
+    /** Cleanup interval in milliseconds (default: 5 minutes) */
+    cleanupIntervalMs?: number;
+}
+/**
+ * Session Pool for Claude CLI session management
+ *
+ * Key design:
+ * - Channel key format: "{source}:{channelId}" (e.g., "discord:123456")
+ * - Sessions expire after timeout (default 30 min)
+ * - Automatic cleanup of stale sessions
+ */
+export declare class SessionPool {
+    private sessions;
+    private config;
+    private cleanupTimer;
+    constructor(config?: SessionPoolConfig);
+    /**
+     * Get or create session ID for a channel
+     *
+     * With --no-session-persistence flag, Claude CLI doesn't lock session IDs.
+     * This allows session reuse for conversation continuity.
+     *
+     * Durable backends own model-aware context compaction. This pool rotates only
+     * for explicit resets and session-lifecycle expiry.
+     * If session is in use, returns busy=true immediately (no waiting).
+     *
+     * @param channelKey - Channel identifier (format: "{source}:{channelId}")
+     * @returns Object with sessionId, isNew flag, and busy status
+     */
+    getSession(channelKey: string): {
+        sessionId: string;
+        isNew: boolean;
+        busy: boolean;
+    };
+    /**
+     * Read-only check for session busy status
+     * Does NOT modify session state (no lock, no messageCount increment)
+     *
+     * @param channelKey - Channel identifier
+     * @returns Object with sessionId (if exists) and busy status
+     */
+    peekSession(channelKey: string): {
+        sessionId?: string;
+        busy: boolean;
+    };
+    /**
+     * Preserve the legacy token-status interface without interpreting billing
+     * usage as context occupancy. Claude Code and the Codex app-server
+     * each compact from their own model-aware request state.
+     *
+     * @param channelKey - Channel identifier
+     * @param _inputTokens - Usage telemetry from this run; recorded separately by AgentLoop
+     * @param _backend - Runtime that owns the durable session
+     * @returns Zero occupancy because the host has no authoritative context-size signal
+     */
+    updateTokens(channelKey: string, _inputTokens: number, _backend?: 'claude' | 'codex'): {
+        totalTokens: number;
+        nearThreshold: boolean;
+    };
+    /**
+     * Get current token usage for a session
+     */
+    getTokenUsage(channelKey: string): number;
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use getSession() instead
+     */
+    getSessionId(channelKey: string): string;
+    /**
+     * Release a session after use
+     * This allows the session to be reused by future requests
+     */
+    releaseSession(channelKey: string, expectedSessionId?: string): void;
+    /**
+     * Override session ID for a channel (e.g., when backend returns its own thread ID)
+     */
+    setSessionId(channelKey: string, sessionId: string): void;
+    /**
+     * Create a new session for a channel
+     */
+    private createSession;
+    /**
+     * Force create a new session (for /clear command)
+     */
+    resetSession(channelKey: string): string;
+    /**
+     * Remove a session without creating a replacement.
+     *
+     * Use this after a failed reset attempt: the next request must observe a
+     * genuinely new session and rebuild its complete policy prompt.
+     */
+    invalidateSession(channelKey: string, expectedSessionId?: string): void;
+    /**
+     * Check if a session exists and is active
+     */
+    hasActiveSession(channelKey: string): boolean;
+    /**
+     * Get session info for a channel
+     */
+    getSessionInfo(channelKey: string): SessionEntry | null;
+    /**
+     * Get all active sessions (for debugging/monitoring)
+     */
+    listSessions(): Map<string, SessionEntry>;
+    /**
+     * Get active session count
+     */
+    getActiveSessionCount(): number;
+    /**
+     * Evict the oldest (least recently used) session
+     */
+    private evictOldestSession;
+    /**
+     * Clean up expired sessions and force-release stuck inUse sessions
+     */
+    cleanup(): number;
+    /**
+     * Start periodic cleanup timer
+     */
+    private startCleanupTimer;
+    /**
+     * Stop cleanup timer and clear all sessions
+     */
+    dispose(): void;
+}
+/**
+ * Get global session pool instance
+ */
+export declare function getSessionPool(): SessionPool;
+/**
+ * Set global session pool instance (for testing)
+ */
+export declare function setSessionPool(pool: SessionPool): void;
+/**
+ * Build channel key from source and channel ID
+ */
+export declare function buildChannelKey(source: string, channelId: string): string;
+export {};
+//# sourceMappingURL=session-pool.d.ts.map

package/dist/runtime/session-pool.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * Session Pool - Claude CLI Session Reuse Manager
+ *
+ * Manages Claude CLI session IDs per channel to enable conversation continuity.
+ * Instead of creating new sessions for each message, reuses existing sessions
+ * so Claude CLI maintains its own conversation history.
+ *
+ * Benefits:
+ * - 6x token reduction (no manual history injection needed)
+ * - Natural conversation flow (Claude remembers context)
+ * - Automatic summarization by Claude when context fills up
+ */
+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.SessionPool = void 0;
+exports.getSessionPool = getSessionPool;
+exports.setSessionPool = setSessionPool;
+exports.buildChannelKey = buildChannelKey;
+const crypto_1 = require("crypto");
+const debugLogger = __importStar(require("../debug-logger.js"));
+const { DebugLogger } = debugLogger;
+const logger = new DebugLogger('SessionPool');
+// Defaults a caller that states nothing gets. The product reads its own
+// config and passes the numbers; a pool does not open a config file.
+const DEFAULT_SESSION_TIMEOUT_MS = 1_800_000;
+const DEFAULT_MAX_SESSIONS = 100;
+const DEFAULT_CLEANUP_INTERVAL_MS = 300_000;
+/**
+ * Session Pool for Claude CLI session management
+ *
+ * Key design:
+ * - Channel key format: "{source}:{channelId}" (e.g., "discord:123456")
+ * - Sessions expire after timeout (default 30 min)
+ * - Automatic cleanup of stale sessions
+ */
+class SessionPool {
+    sessions = new Map();
+    config;
+    cleanupTimer = null;
+    constructor(config = {}) {
+        this.config = {
+            sessionTimeoutMs: config.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS,
+            maxSessions: config.maxSessions ?? DEFAULT_MAX_SESSIONS,
+            cleanupIntervalMs: config.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS,
+        };
+        // Start periodic cleanup
+        this.startCleanupTimer();
+    }
+    /**
+     * Get or create session ID for a channel
+     *
+     * With --no-session-persistence flag, Claude CLI doesn't lock session IDs.
+     * This allows session reuse for conversation continuity.
+     *
+     * Durable backends own model-aware context compaction. This pool rotates only
+     * for explicit resets and session-lifecycle expiry.
+     * If session is in use, returns busy=true immediately (no waiting).
+     *
+     * @param channelKey - Channel identifier (format: "{source}:{channelId}")
+     * @returns Object with sessionId, isNew flag, and busy status
+     */
+    getSession(channelKey) {
+        const existing = this.sessions.get(channelKey);
+        const now = Date.now();
+        // Check if existing session is still valid
+        if (existing) {
+            const isExpired = now - existing.lastActive > this.config.sessionTimeoutMs;
+            if (isExpired) {
+                this.sessions.delete(channelKey);
+                logger.info(`Session expired for ${channelKey}, creating new one`);
+            }
+            else if (existing.inUse) {
+                // Session is currently in use - return busy immediately
+                // Still update lastActive and messageCount for queued messages
+                existing.lastActive = now;
+                existing.messageCount++;
+                logger.debug(`Session busy for ${channelKey}, will be queued`);
+                return { sessionId: existing.sessionId, isNew: false, busy: true };
+            }
+            else {
+                // Reuse existing session
+                existing.lastActive = now;
+                existing.messageCount++;
+                existing.inUse = true; // Lock the session
+                logger.debug(`Reusing session for ${channelKey}: ${existing.sessionId} (msg #${existing.messageCount})`);
+                return { sessionId: existing.sessionId, isNew: false, busy: false };
+            }
+        }
+        // Create new session
+        const sessionId = this.createSession(channelKey);
+        return { sessionId, isNew: true, busy: false };
+    }
+    /**
+     * Read-only check for session busy status
+     * Does NOT modify session state (no lock, no messageCount increment)
+     *
+     * @param channelKey - Channel identifier
+     * @returns Object with sessionId (if exists) and busy status
+     */
+    peekSession(channelKey) {
+        const existing = this.sessions.get(channelKey);
+        if (!existing) {
+            return { busy: false };
+        }
+        return { sessionId: existing.sessionId, busy: existing.inUse };
+    }
+    /**
+     * Preserve the legacy token-status interface without interpreting billing
+     * usage as context occupancy. Claude Code and the Codex app-server
+     * each compact from their own model-aware request state.
+     *
+     * @param channelKey - Channel identifier
+     * @param _inputTokens - Usage telemetry from this run; recorded separately by AgentLoop
+     * @param _backend - Runtime that owns the durable session
+     * @returns Zero occupancy because the host has no authoritative context-size signal
+     */
+    updateTokens(channelKey, _inputTokens, _backend) {
+        const existing = this.sessions.get(channelKey);
+        if (!existing) {
+            return { totalTokens: 0, nearThreshold: false };
+        }
+        existing.totalInputTokens = 0;
+        return { totalTokens: 0, nearThreshold: false };
+    }
+    /**
+     * Get current token usage for a session
+     */
+    getTokenUsage(channelKey) {
+        const existing = this.sessions.get(channelKey);
+        return existing?.totalInputTokens ?? 0;
+    }
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use getSession() instead
+     */
+    getSessionId(channelKey) {
+        return this.getSession(channelKey).sessionId;
+    }
+    /**
+     * Release a session after use
+     * This allows the session to be reused by future requests
+     */
+    releaseSession(channelKey, expectedSessionId) {
+        const existing = this.sessions.get(channelKey);
+        if (existing && (!expectedSessionId || existing.sessionId === expectedSessionId)) {
+            existing.inUse = false;
+            console.log(`[SessionPool] Released session for ${channelKey}: ${existing.sessionId}`);
+        }
+    }
+    /**
+     * Override session ID for a channel (e.g., when backend returns its own thread ID)
+     */
+    setSessionId(channelKey, sessionId) {
+        const existing = this.sessions.get(channelKey);
+        const now = Date.now();
+        if (existing) {
+            existing.sessionId = sessionId;
+            existing.lastActive = now;
+            existing.inUse = true;
+            console.log(`[SessionPool] Updated session for ${channelKey}: ${sessionId}`);
+            return;
+        }
+        const entry = {
+            sessionId,
+            lastActive: now,
+            messageCount: 1,
+            createdAt: now,
+            inUse: true,
+            totalInputTokens: 0,
+        };
+        this.sessions.set(channelKey, entry);
+        console.log(`[SessionPool] Created session for ${channelKey}: ${sessionId}`);
+    }
+    /**
+     * Create a new session for a channel
+     */
+    createSession(channelKey) {
+        const now = Date.now();
+        const sessionId = (0, crypto_1.randomUUID)();
+        // Enforce max sessions limit
+        if (this.sessions.size >= this.config.maxSessions) {
+            this.evictOldestSession();
+        }
+        const entry = {
+            sessionId,
+            lastActive: now,
+            messageCount: 1,
+            createdAt: now,
+            inUse: true, // Lock on creation
+            totalInputTokens: 0,
+        };
+        this.sessions.set(channelKey, entry);
+        console.log(`[SessionPool] Created new session for ${channelKey}: ${sessionId}`);
+        return sessionId;
+    }
+    /**
+     * Force create a new session (for /clear command)
+     */
+    resetSession(channelKey) {
+        this.sessions.delete(channelKey);
+        return this.createSession(channelKey);
+    }
+    /**
+     * Remove a session without creating a replacement.
+     *
+     * Use this after a failed reset attempt: the next request must observe a
+     * genuinely new session and rebuild its complete policy prompt.
+     */
+    invalidateSession(channelKey, expectedSessionId) {
+        const existing = this.sessions.get(channelKey);
+        if (existing && expectedSessionId && existing.sessionId !== expectedSessionId) {
+            return;
+        }
+        if (existing && this.sessions.delete(channelKey)) {
+            console.log(`[SessionPool] Invalidated session for ${channelKey}`);
+        }
+    }
+    /**
+     * Check if a session exists and is active
+     */
+    hasActiveSession(channelKey) {
+        const existing = this.sessions.get(channelKey);
+        if (!existing) {
+            return false;
+        }
+        const isExpired = Date.now() - existing.lastActive > this.config.sessionTimeoutMs;
+        return !isExpired;
+    }
+    /**
+     * Get session info for a channel
+     */
+    getSessionInfo(channelKey) {
+        return this.sessions.get(channelKey) || null;
+    }
+    /**
+     * Get all active sessions (for debugging/monitoring)
+     */
+    listSessions() {
+        return new Map(this.sessions);
+    }
+    /**
+     * Get active session count
+     */
+    getActiveSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * Evict the oldest (least recently used) session
+     */
+    evictOldestSession() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.sessions) {
+            if (entry.lastActive < oldestTime) {
+                oldestTime = entry.lastActive;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.sessions.delete(oldestKey);
+            console.log(`[SessionPool] Evicted oldest session: ${oldestKey}`);
+        }
+    }
+    /**
+     * Clean up expired sessions and force-release stuck inUse sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        const STUCK_THRESHOLD_MS = 15 * 60 * 1000; // 15 minutes
+        for (const [key, entry] of this.sessions) {
+            if (now - entry.lastActive > this.config.sessionTimeoutMs) {
+                this.sessions.delete(key);
+                cleaned++;
+            }
+            else if (entry.inUse && now - entry.lastActive > STUCK_THRESHOLD_MS) {
+                entry.inUse = false;
+                console.log(`[SessionPool] Force-released stuck session for ${key} (inUse for ${Math.round((now - entry.lastActive) / 1000)}s)`);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[SessionPool] Cleaned up ${cleaned} expired/stuck sessions`);
+        }
+        return cleaned;
+    }
+    /**
+     * Start periodic cleanup timer
+     */
+    startCleanupTimer() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.cleanupIntervalMs);
+        // Don't prevent process exit
+        this.cleanupTimer.unref();
+    }
+    /**
+     * Stop cleanup timer and clear all sessions
+     */
+    dispose() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        this.sessions.clear();
+    }
+}
+exports.SessionPool = SessionPool;
+/**
+ * Global session pool instance
+ */
+let globalSessionPool = null;
+/**
+ * Get global session pool instance
+ */
+function getSessionPool() {
+    if (!globalSessionPool) {
+        globalSessionPool = new SessionPool();
+    }
+    return globalSessionPool;
+}
+/**
+ * Set global session pool instance (for testing)
+ */
+function setSessionPool(pool) {
+    globalSessionPool = pool;
+}
+/**
+ * Build channel key from source and channel ID
+ */
+function buildChannelKey(source, channelId) {
+    return `${source}:${channelId}`;
+}
+//# sourceMappingURL=session-pool.js.map

package/dist/runtime/stimulus-payload.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from '../memory/judgment-types.js';
+/** Reject lossy JavaScript values before a producer receives a durable receipt. */
+export declare function encodeStimulusPayload(value: unknown): string | null;
+export declare function decodeStimulusPayload(encoded: string | null): JsonValue | undefined;
+//# sourceMappingURL=stimulus-payload.d.ts.map

package/dist/runtime/stimulus-payload.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeStimulusPayload = encodeStimulusPayload;
+exports.decodeStimulusPayload = decodeStimulusPayload;
+const canonicalize_js_1 = require("../canonicalize.js");
+/** Reject lossy JavaScript values before a producer receives a durable receipt. */
+function encodeStimulusPayload(value) {
+    if (value === undefined)
+        return null;
+    const ancestors = new Set();
+    const visit = (item) => {
+        if (item === null || typeof item === 'string' || typeof item === 'boolean')
+            return;
+        if (typeof item === 'number' && Number.isFinite(item))
+            return;
+        if (typeof item !== 'object' || item === null) {
+            throw new Error('Mailbox payload must contain only JSON values');
+        }
+        const array = Array.isArray(item);
+        const prototype = Object.getPrototypeOf(item);
+        if (!array && prototype !== Object.prototype && prototype !== null) {
+            throw new Error('Mailbox payload requires plain JSON objects');
+        }
+        if (ancestors.has(item))
+            throw new Error('Mailbox payload cannot contain cycles');
+        ancestors.add(item);
+        const keys = Reflect.ownKeys(item).filter((key) => !array || key !== 'length');
+        if (array && (keys.length !== item.length || keys.some((key, i) => key !== String(i)))) {
+            throw new Error('Mailbox payload requires dense JSON arrays');
+        }
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (typeof key !== 'string' || !descriptor.enumerable || !('value' in descriptor)) {
+                throw new Error('Mailbox payload requires enumerable JSON data properties');
+            }
+            visit(descriptor.value);
+        }
+        ancestors.delete(item);
+    };
+    visit(value);
+    return (0, canonicalize_js_1.canonicalizeJSON)(value);
+}
+function decodeStimulusPayload(encoded) {
+    if (encoded === null)
+        return undefined;
+    const value = JSON.parse(encoded);
+    encodeStimulusPayload(value);
+    return value;
+}
+//# sourceMappingURL=stimulus-payload.js.map

package/dist/runtime/subagent-bridge.d.ts

@@ -0,0 +1,24 @@
+import type { HostToolBridge } from './drivers/types.js';
+/** What the host is asked for when a native harness identifies a child. */
+export interface SubagentBridgeRequest {
+    /** The PARENT's session key; a child never owns a session of its own. */
+    sessionKey: string;
+    parentThreadId: string;
+    agentThreadId: string;
+    agentPath: string;
+}
+/**
+ * One child's own authority: its tools and the release that closes its run.
+ *
+ * The native transport chooses the terminal observation: Codex's child event or
+ * the enclosing Claude turn's settlement after its socket calls drain. `unknown`
+ * means completion was not confirmed and must not be recorded as success.
+ */
+export interface SubagentBridge {
+    bridge: HostToolBridge;
+    release: (outcome: {
+        status: 'completed' | 'failed' | 'interrupted' | 'unknown';
+        error?: string;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=subagent-bridge.d.ts.map

package/dist/{agent-graph/types.js → runtime/subagent-bridge.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=subagent-bridge.js.map

package/dist/runtime/text-completion.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The one model the runtime opens, as the shape a caller may ask it for text.
+ *
+ * `memory/api.ts` reached a local Ollama endpoint directly when a search asked
+ * for LLM reranking: a second place opening a model, decided inside the
+ * library rather than by whoever runs it (§2.1 — one place opens the model).
+ *
+ * A runner is stated by the host that starts the runtime and reaches an action
+ * through the catalog. A host that states none has no model for this, which is
+ * exactly what a host whose model is unreachable already had: the call falls
+ * back to the ranking it already computed and says so.
+ */
+export interface TextCompletionOptions {
+    /** 'json' asks the model to answer with JSON and nothing else. */
+    format?: 'json' | 'text';
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+}
+/** Ask the runtime's model for one completion. Rejects rather than answering falsely. */
+export type TextCompletion = (prompt: string, options?: TextCompletionOptions) => Promise<string>;
+//# sourceMappingURL=text-completion.d.ts.map

package/dist/{agent-situation/types.js → runtime/text-completion.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=text-completion.js.map

package/dist/runtime/token-estimator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TokenEstimator — singleton wrapper around js-tiktoken (cl100k_base).
+ *
+ * Provides accurate token counting for Korean + English text.
+ * Falls back to byte-length heuristic if WASM init fails or during loading.
+ *
+ * Uses dynamic import to avoid blocking vitest fork initialization.
+ */
+/**
+ * Initialize the encoder asynchronously. Safe to call multiple times.
+ */
+export declare function initTokenEstimator(): Promise<void>;
+/**
+ * Count tokens in text. Uses js-tiktoken if available, else byte fallback.
+ */
+export declare function countTokens(text: string): number;
+/**
+ * Reset singleton state (for testing).
+ */
+export declare function resetTokenEstimator(): void;
+/**
+ * Force fallback mode (for testing).
+ */
+export declare function forceFallbackMode(): void;
+//# sourceMappingURL=token-estimator.d.ts.map