@psiclawops/hypermem 0.5.0 → 0.5.2

package/dist/provider-translator.js

@@ -0,0 +1,403 @@
+/**
+ * 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

@@ -0,0 +1,76 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,179 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+/**
+ * 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