@psiclawops/hypermem 0.9.0 → 0.9.1

package/dist/provider-translator.js

@@ -1,403 +0,0 @@
-/**
- * hypermem Provider Translator
- *
- * Converts between provider-neutral (NeutralMessage) and provider-specific formats.
- * This is the ONLY place where provider-specific formatting exists.
- * Storage is always neutral. Translation happens at the send/receive boundary.
- *
- * This eliminates grafting/stripping entirely — tool calls are stored as structured
- * data, and each provider gets the format it expects at send time.
- */
-function summarizeOrphanToolResult(tr) {
-    const toolName = tr.name || 'tool';
-    const status = tr.isError ? 'error' : 'result';
-    const content = (tr.content || '').replace(/\s+/g, ' ').trim();
-    const preview = content.length > 160 ? `${content.slice(0, 157)}...` : content;
-    return preview
-        ? `[${toolName} ${status} omitted: missing matching tool call] ${preview}`
-        : `[${toolName} ${status} omitted: missing matching tool call]`;
-}
-/**
- * Final pair-integrity sweep before provider translation.
- *
- * Invariant: never emit a tool_result unless its matching tool_use/tool_call
- * exists in the immediately prior assistant message with the same ID.
- *
- * If the pair is broken, degrade the orphan tool_result into plain user text
- * so providers never see an invalid tool_result block.
- */
-export function repairToolCallPairs(messages) {
-    const repaired = [];
-    for (const msg of messages) {
-        if (msg.role !== 'user' || !msg.toolResults || msg.toolResults.length === 0) {
-            repaired.push(msg);
-            continue;
-        }
-        const prev = repaired[repaired.length - 1];
-        const validCallIds = new Set(prev?.role === 'assistant' && prev.toolCalls
-            ? prev.toolCalls.map(tc => tc.id)
-            : []);
-        const keptResults = msg.toolResults.filter(tr => validCallIds.has(tr.callId));
-        const orphanResults = msg.toolResults.filter(tr => !validCallIds.has(tr.callId));
-        if (orphanResults.length === 0) {
-            repaired.push(msg);
-            continue;
-        }
-        const orphanText = orphanResults.map(summarizeOrphanToolResult).join('\n');
-        const mergedText = [msg.textContent, orphanText].filter(Boolean).join('\n');
-        if (keptResults.length > 0) {
-            repaired.push({
-                ...msg,
-                textContent: mergedText || msg.textContent,
-                toolResults: keptResults,
-            });
-            continue;
-        }
-        repaired.push({
-            ...msg,
-            textContent: mergedText || msg.textContent || '[tool result omitted: missing matching tool call]',
-            toolResults: null,
-        });
-    }
-    return repaired;
-}
-import { createHash } from 'node:crypto';
-// ─── ID Generation ───────────────────────────────────────────────
-let idCounter = 0;
-/**
- * Generate a hypermem-native tool call ID.
- * These are provider-neutral and deterministic within a session.
- */
-export function generateToolCallId() {
-    idCounter++;
-    const timestamp = Date.now().toString(36);
-    const counter = idCounter.toString(36).padStart(4, '0');
-    return `hm_${timestamp}_${counter}`;
-}
-/**
- * Convert a provider-specific tool call ID to a hypermem ID.
- * Deterministic: same input always produces same output.
- */
-export function normalizeToolCallId(providerId) {
-    if (providerId.startsWith('hm_'))
-        return providerId; // already normalized
-    const hash = createHash('sha256').update(providerId).digest('hex').substring(0, 12);
-    return `hm_${hash}`;
-}
-export function detectProvider(providerString) {
-    if (!providerString)
-        return 'unknown';
-    const lower = providerString.toLowerCase();
-    if (lower.includes('anthropic') || lower.includes('claude'))
-        return 'anthropic';
-    if (lower.includes('codex') || lower.includes('responses'))
-        return 'openai-responses';
-    if (lower.includes('openai') || lower.includes('gpt') || lower.includes('copilot'))
-        return 'openai';
-    return 'unknown';
-}
-// ─── To Provider Format ──────────────────────────────────────────
-/**
- * Convert neutral messages to Anthropic Messages API format.
- *
- * Prompt caching (DYNAMIC_BOUNDARY):
- * Anthropic supports prompt caching via cache_control on content blocks.
- * The last system message BEFORE the dynamicBoundary marker gets
- * cache_control: {type: "ephemeral"} to mark the static/dynamic boundary.
- *
- * Static (cacheable): system prompt + identity + stable output profile prefix
- * Dynamic (not cacheable): context block (facts/recall/recent actions), conversation history
- *
- * This allows Anthropic to cache the static prefix and skip re-tokenizing it.
- */
-function toAnthropic(messages) {
-    const result = [];
-    // Find the last static system message index (before any dynamicBoundary message)
-    // so we can mark it with cache_control.
-    let lastStaticSystemIdx = -1;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === 'system' && !msg.metadata?.dynamicBoundary) {
-            lastStaticSystemIdx = i;
-        }
-        else if (msg.metadata?.dynamicBoundary) {
-            // Stop scanning — everything after the boundary marker is dynamic
-            break;
-        }
-    }
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === 'system') {
-            // Anthropic system messages are handled separately (system parameter)
-            // Include them as-is; the gateway will extract them.
-            // Mark the last static system message as the cache boundary.
-            const isLastStatic = i === lastStaticSystemIdx;
-            const providerMsg = {
-                role: 'system',
-                content: msg.textContent || '',
-            };
-            if (isLastStatic) {
-                // Add cache_control as a hint to the gateway/Anthropic API.
-                // The gateway is responsible for lifting this into the correct API position.
-                providerMsg.cache_control = { type: 'ephemeral' };
-            }
-            result.push(providerMsg);
-            continue;
-        }
-        if (msg.role === 'assistant') {
-            const content = [];
-            if (msg.textContent) {
-                content.push({ type: 'text', text: msg.textContent });
-            }
-            if (msg.toolCalls) {
-                for (const tc of msg.toolCalls) {
-                    // tc may be a NeutralToolCall { id, name, arguments: string }
-                    // or a raw OpenClaw content block { type, id, name, input: object }
-                    const rawTc = tc;
-                    let input;
-                    if (rawTc.input !== undefined) {
-                        // Raw content block format — input is already an object
-                        input = typeof rawTc.input === 'string' ? JSON.parse(rawTc.input) : rawTc.input;
-                    }
-                    else if (tc.arguments !== undefined) {
-                        // NeutralToolCall format — arguments is a JSON string
-                        input = typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : (tc.arguments ?? {});
-                    }
-                    else {
-                        input = {};
-                    }
-                    content.push({
-                        type: 'tool_use',
-                        id: tc.id,
-                        name: tc.name,
-                        input,
-                    });
-                }
-            }
-            result.push({
-                role: 'assistant',
-                content: content.length === 1 && typeof content[0] === 'object' && content[0].type === 'text'
-                    ? msg.textContent || ''
-                    : content,
-            });
-            continue;
-        }
-        if (msg.role === 'user') {
-            // Tool results go as user messages with tool_result content blocks
-            if (msg.toolResults && msg.toolResults.length > 0) {
-                const content = [];
-                for (const tr of msg.toolResults) {
-                    content.push({
-                        type: 'tool_result',
-                        tool_use_id: tr.callId,
-                        content: tr.content,
-                        is_error: tr.isError || false,
-                    });
-                }
-                result.push({ role: 'user', content });
-            }
-            else {
-                result.push({ role: 'user', content: msg.textContent || '' });
-            }
-            continue;
-        }
-    }
-    return result;
-}
-/**
- * Convert neutral messages to OpenAI Chat Completions API format.
- */
-function toOpenAI(messages) {
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === 'system') {
-            result.push({ role: 'system', content: msg.textContent || '' });
-            continue;
-        }
-        if (msg.role === 'assistant') {
-            const providerMsg = {
-                role: 'assistant',
-                content: msg.textContent || null,
-            };
-            if (msg.toolCalls && msg.toolCalls.length > 0) {
-                providerMsg.tool_calls = msg.toolCalls.map(tc => {
-                    // Handle both NeutralToolCall { arguments: string } and raw content block { input: object }
-                    const rawTc = tc;
-                    let args;
-                    if (rawTc.input !== undefined) {
-                        args = typeof rawTc.input === 'string' ? rawTc.input : JSON.stringify(rawTc.input);
-                    }
-                    else if (tc.arguments !== undefined) {
-                        args = typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments);
-                    }
-                    else {
-                        args = '{}';
-                    }
-                    return {
-                        id: tc.id,
-                        type: 'function',
-                        function: {
-                            name: tc.name,
-                            arguments: args,
-                        },
-                    };
-                });
-            }
-            result.push(providerMsg);
-            continue;
-        }
-        if (msg.role === 'user') {
-            if (msg.toolResults && msg.toolResults.length > 0) {
-                // OpenAI tool results are separate "tool" role messages
-                for (const tr of msg.toolResults) {
-                    result.push({
-                        role: 'tool',
-                        tool_call_id: tr.callId,
-                        content: tr.content,
-                    });
-                }
-            }
-            else {
-                result.push({ role: 'user', content: msg.textContent || '' });
-            }
-            continue;
-        }
-    }
-    return result;
-}
-/**
- * Convert neutral messages to OpenAI Responses API format.
- */
-function toOpenAIResponses(messages) {
-    // Responses API uses a different item format
-    // For now, use the same as Chat Completions — the gateway handles the conversion
-    // This is a stub for when we need direct Responses API support
-    return toOpenAI(messages);
-}
-/**
- * Convert neutral messages to provider-specific format.
- */
-export function toProviderFormat(messages, provider) {
-    const repairedMessages = repairToolCallPairs(messages);
-    const providerType = detectProvider(provider);
-    switch (providerType) {
-        case 'anthropic':
-            return toAnthropic(repairedMessages);
-        case 'openai':
-            return toOpenAI(repairedMessages);
-        case 'openai-responses':
-            return toOpenAIResponses(repairedMessages);
-        default:
-            // Default to OpenAI format as it's most widely compatible
-            return toOpenAI(repairedMessages);
-    }
-}
-// ─── From Provider Format ────────────────────────────────────────
-/**
- * Convert an Anthropic response to neutral format.
- */
-function fromAnthropic(response) {
-    const content = response.content;
-    let textContent = null;
-    let toolCalls = null;
-    if (typeof content === 'string') {
-        textContent = content;
-    }
-    else if (Array.isArray(content)) {
-        const textParts = [];
-        const tools = [];
-        for (const block of content) {
-            if (block.type === 'text') {
-                textParts.push(block.text);
-            }
-            else if (block.type === 'tool_use') {
-                tools.push({
-                    id: normalizeToolCallId(block.id),
-                    name: block.name,
-                    arguments: JSON.stringify(block.input),
-                });
-            }
-        }
-        if (textParts.length > 0)
-            textContent = textParts.join('\n');
-        if (tools.length > 0)
-            toolCalls = tools;
-    }
-    return {
-        role: 'assistant',
-        textContent,
-        toolCalls,
-        toolResults: null,
-        metadata: {
-            originalProvider: 'anthropic',
-            stopReason: response.stop_reason,
-            model: response.model,
-        },
-    };
-}
-/**
- * Convert an OpenAI response choice to neutral format.
- */
-function fromOpenAI(choice) {
-    const message = choice.message
-        || choice;
-    const textContent = message.content || null;
-    let toolCalls = null;
-    const rawToolCalls = message.tool_calls;
-    if (rawToolCalls && rawToolCalls.length > 0) {
-        toolCalls = rawToolCalls.map(tc => ({
-            id: normalizeToolCallId(tc.id),
-            name: tc.function.name,
-            arguments: tc.function.arguments,
-        }));
-    }
-    return {
-        role: 'assistant',
-        textContent,
-        toolCalls,
-        toolResults: null,
-        metadata: {
-            originalProvider: 'openai',
-            finishReason: message.finish_reason || choice.finish_reason,
-        },
-    };
-}
-/**
- * Convert a provider-specific response to neutral format.
- */
-export function fromProviderFormat(response, provider) {
-    const providerType = detectProvider(provider);
-    switch (providerType) {
-        case 'anthropic':
-            return fromAnthropic(response);
-        case 'openai':
-        case 'openai-responses':
-            return fromOpenAI(response);
-        default:
-            return fromOpenAI(response);
-    }
-}
-/**
- * Convert a user message (from chat input) to neutral format.
- */
-export function userMessageToNeutral(content, metadata) {
-    return {
-        role: 'user',
-        textContent: content,
-        toolCalls: null,
-        toolResults: null,
-        metadata,
-    };
-}
-/**
- * Convert tool results to a neutral user message.
- */
-export function toolResultsToNeutral(results) {
-    return {
-        role: 'user',
-        textContent: null,
-        toolCalls: null,
-        toolResults: results,
-    };
-}
-//# sourceMappingURL=provider-translator.js.map

package/dist/rate-limiter.d.ts

@@ -1,76 +0,0 @@
-/**
- * hypermem Rate Limiter
- *
- * Token-bucket rate limiter for embedding API calls.
- * Prevents hammering Ollama during bulk indexing.
- *
- * Strategy:
- *   - Burst: allow immediate calls up to bucket capacity
- *   - Sustained: refill tokens at a steady rate
- *   - Backpressure: when tokens exhausted, delay until available
- *   - Priority: high-priority requests (user-facing recall) get reserved tokens
- *
- * Usage:
- *   const limiter = new RateLimiter({ tokensPerSecond: 5, burstSize: 10 });
- *   await limiter.acquire();  // Waits if necessary
- *   const embeddings = await generateEmbeddings(texts);
- */
-export interface RateLimiterConfig {
-    /** Tokens refilled per second. Default: 5 */
-    tokensPerSecond: number;
-    /** Maximum burst capacity. Default: 10 */
-    burstSize: number;
-    /** Reserved tokens for high-priority requests. Default: 2 */
-    reservedHigh: number;
-    /** Maximum wait time before rejecting (ms). Default: 30000 (30s) */
-    maxWaitMs: number;
-}
-export type Priority = 'high' | 'normal' | 'low';
-export declare class RateLimiter {
-    private tokens;
-    private lastRefill;
-    private readonly config;
-    private waitQueue;
-    private refillTimer;
-    private _totalAcquired;
-    private _totalWaited;
-    private _totalRejected;
-    constructor(config?: Partial<RateLimiterConfig>);
-    /**
-     * Acquire tokens. Blocks until tokens are available or maxWaitMs expires.
-     *
-     * @param count - Number of tokens to acquire (default 1)
-     * @param priority - Request priority (high gets reserved tokens)
-     * @throws Error if wait exceeds maxWaitMs
-     */
-    acquire(count?: number, priority?: Priority): Promise<void>;
-    /**
-     * Try to acquire tokens without waiting.
-     * Returns true if tokens were acquired, false if not.
-     */
-    tryAcquire(count?: number, priority?: Priority): boolean;
-    /**
-     * Get current limiter state.
-     */
-    get state(): {
-        availableTokens: number;
-        pendingRequests: number;
-        stats: {
-            acquired: number;
-            waited: number;
-            rejected: number;
-        };
-    };
-    /**
-     * Stop the refill timer.
-     */
-    destroy(): void;
-    private refill;
-    private processQueue;
-}
-/**
- * Rate-limited embedding generator.
- * Wraps generateEmbeddings with rate limiting.
- */
-export declare function createRateLimitedEmbedder(embedFn: (texts: string[]) => Promise<Float32Array[]>, limiter: RateLimiter): (texts: string[], priority?: Priority) => Promise<Float32Array[]>;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/rate-limiter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../src/rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,6CAA6C;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AASjD,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,SAAS,CAMT;IACR,OAAO,CAAC,WAAW,CAA+C;IAClE,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,cAAc,CAAK;gBAEf,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAS/C;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,GAAE,MAAU,EAAE,QAAQ,GAAE,QAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC9E;;;OAGG;IACH,UAAU,CAAC,KAAK,GAAE,MAAU,EAAE,QAAQ,GAAE,QAAmB,GAAG,OAAO;IAgBrE;;OAEG;IACH,IAAI,KAAK,IAAI;QACX,eAAe,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/D,CAWA;IAED;;OAEG;IACH,OAAO,IAAI,IAAI;IAcf,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,YAAY;CAiCrB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,EACrD,OAAO,EAAE,WAAW,GACnB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CASnE"}

package/dist/rate-limiter.js

@@ -1,179 +0,0 @@
-/**
- * hypermem Rate Limiter
- *
- * Token-bucket rate limiter for embedding API calls.
- * Prevents hammering Ollama during bulk indexing.
- *
- * Strategy:
- *   - Burst: allow immediate calls up to bucket capacity
- *   - Sustained: refill tokens at a steady rate
- *   - Backpressure: when tokens exhausted, delay until available
- *   - Priority: high-priority requests (user-facing recall) get reserved tokens
- *
- * Usage:
- *   const limiter = new RateLimiter({ tokensPerSecond: 5, burstSize: 10 });
- *   await limiter.acquire();  // Waits if necessary
- *   const embeddings = await generateEmbeddings(texts);
- */
-const DEFAULT_CONFIG = {
-    tokensPerSecond: 5,
-    burstSize: 10,
-    reservedHigh: 2,
-    maxWaitMs: 30000,
-};
-export class RateLimiter {
-    tokens;
-    lastRefill;
-    config;
-    waitQueue = [];
-    refillTimer = null;
-    _totalAcquired = 0;
-    _totalWaited = 0;
-    _totalRejected = 0;
-    constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.tokens = this.config.burstSize;
-        this.lastRefill = Date.now();
-        // Refill tokens periodically
-        this.refillTimer = setInterval(() => this.refill(), 200); // 5x per second
-    }
-    /**
-     * Acquire tokens. Blocks until tokens are available or maxWaitMs expires.
-     *
-     * @param count - Number of tokens to acquire (default 1)
-     * @param priority - Request priority (high gets reserved tokens)
-     * @throws Error if wait exceeds maxWaitMs
-     */
-    async acquire(count = 1, priority = 'normal') {
-        this.refill();
-        // High priority can use reserved tokens
-        const available = priority === 'high'
-            ? this.tokens
-            : Math.max(0, this.tokens - this.config.reservedHigh);
-        if (available >= count) {
-            this.tokens -= count;
-            this._totalAcquired += count;
-            return;
-        }
-        // Need to wait
-        this._totalWaited++;
-        const deadline = Date.now() + this.config.maxWaitMs;
-        return new Promise((resolve, reject) => {
-            this.waitQueue.push({
-                resolve,
-                reject,
-                priority,
-                tokensNeeded: count,
-                deadline,
-            });
-            // Sort by priority (high first) then by deadline (earliest first)
-            this.waitQueue.sort((a, b) => {
-                const priOrder = { high: 0, normal: 1, low: 2 };
-                const priDiff = priOrder[a.priority] - priOrder[b.priority];
-                if (priDiff !== 0)
-                    return priDiff;
-                return a.deadline - b.deadline;
-            });
-        });
-    }
-    /**
-     * Try to acquire tokens without waiting.
-     * Returns true if tokens were acquired, false if not.
-     */
-    tryAcquire(count = 1, priority = 'normal') {
-        this.refill();
-        const available = priority === 'high'
-            ? this.tokens
-            : Math.max(0, this.tokens - this.config.reservedHigh);
-        if (available >= count) {
-            this.tokens -= count;
-            this._totalAcquired += count;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get current limiter state.
-     */
-    get state() {
-        this.refill();
-        return {
-            availableTokens: Math.floor(this.tokens),
-            pendingRequests: this.waitQueue.length,
-            stats: {
-                acquired: this._totalAcquired,
-                waited: this._totalWaited,
-                rejected: this._totalRejected,
-            },
-        };
-    }
-    /**
-     * Stop the refill timer.
-     */
-    destroy() {
-        if (this.refillTimer) {
-            clearInterval(this.refillTimer);
-            this.refillTimer = null;
-        }
-        // Reject all pending
-        for (const waiter of this.waitQueue) {
-            waiter.reject(new Error('Rate limiter destroyed'));
-        }
-        this.waitQueue = [];
-    }
-    // ─── Internal ──────────────────────────────────────────────
-    refill() {
-        const now = Date.now();
-        const elapsed = (now - this.lastRefill) / 1000; // seconds
-        const newTokens = elapsed * this.config.tokensPerSecond;
-        if (newTokens > 0) {
-            this.tokens = Math.min(this.config.burstSize, this.tokens + newTokens);
-            this.lastRefill = now;
-        }
-        // Process wait queue
-        this.processQueue();
-    }
-    processQueue() {
-        const now = Date.now();
-        const toRemove = [];
-        for (let i = 0; i < this.waitQueue.length; i++) {
-            const waiter = this.waitQueue[i];
-            // Check deadline
-            if (now > waiter.deadline) {
-                waiter.reject(new Error(`Rate limit wait exceeded ${this.config.maxWaitMs}ms`));
-                this._totalRejected++;
-                toRemove.push(i);
-                continue;
-            }
-            // Check if tokens available
-            const available = waiter.priority === 'high'
-                ? this.tokens
-                : Math.max(0, this.tokens - this.config.reservedHigh);
-            if (available >= waiter.tokensNeeded) {
-                this.tokens -= waiter.tokensNeeded;
-                this._totalAcquired += waiter.tokensNeeded;
-                waiter.resolve();
-                toRemove.push(i);
-            }
-        }
-        // Remove processed entries (reverse order to maintain indices)
-        for (let i = toRemove.length - 1; i >= 0; i--) {
-            this.waitQueue.splice(toRemove[i], 1);
-        }
-    }
-}
-/**
- * Rate-limited embedding generator.
- * Wraps generateEmbeddings with rate limiting.
- */
-export function createRateLimitedEmbedder(embedFn, limiter) {
-    return async (texts, priority = 'normal') => {
-        if (texts.length === 0)
-            return [];
-        // Each batch counts as 1 token regardless of batch size
-        // This limits the number of API calls, not the number of texts
-        await limiter.acquire(1, priority);
-        return embedFn(texts);
-    };
-}
-//# sourceMappingURL=rate-limiter.js.map

package/dist/repair-tool-pairs.d.ts

@@ -1,38 +0,0 @@
-/**
- * repair-tool-pairs.ts
- *
- * Strips orphaned tool result entries from a pi-agent message array.
- *
- * Background: HyperMem compaction and in-memory trim passes can remove assistant
- * messages that contain tool_use/toolCall blocks without removing the corresponding
- * tool result messages that follow them. Anthropic and Gemini reject these orphaned
- * tool results with a 400 error.
- *
- * This module provides a pure repair function that can be applied at any output
- * boundary to sanitise the message list before it reaches the provider.
- *
- * Supported formats:
- *   - pi-agent: role:'toolResult' messages with toolCallId field
- *   - Anthropic native: user messages with content blocks of type:'tool_result' and tool_use_id
- *
- * Returns a new array. Does not mutate the input.
- */
-type AnyMessage = Record<string, unknown>;
-/**
- * Repair orphaned tool pairs in a pi-agent / OpenClaw message array.
- *
- * Orphan types handled:
- *   1. role:'toolResult' message whose toolCallId has no matching toolCall/tool_use
- *      block in any assistant message in the array.
- *   2. User message whose content contains only type:'tool_result' blocks where all
- *      of those blocks reference a tool_use_id that does not appear in any assistant
- *      message in the array. (Anthropic-native format.)
- *
- * Also strips orphaned assistant messages that contain ONLY tool_use/toolCall blocks
- * where none of those calls has a corresponding tool result anywhere in the array.
- *
- * Returns a new array (does not mutate input).
- */
-export declare function repairToolPairs(messages: AnyMessage[]): AnyMessage[];
-export {};
-//# sourceMappingURL=repair-tool-pairs.d.ts.map