@juspay/neurolink 9.87.3 → 9.88.0

package/dist/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/core/conversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
 export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
@@ -56,6 +56,16 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
     private createNewSession;
     private enforceSessionLimit;
     getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     clearSession(sessionId: string): Promise<boolean>;
     clearAllSessions(): Promise<void>;
     /**

package/dist/lib/core/conversationMemoryManager.js

@@ -292,6 +292,50 @@ export class ConversationMemoryManager {
             totalTurns,
         };
     }
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const now = Date.now();
+        return sessions
+            .filter((session) => !userId || session.userId === userId)
+            .map((session) => {
+            const lastActive = this.formatTimeAgo(now - session.lastActivity);
+            return {
+                id: session.sessionId,
+                title: session.sessionId, // In-memory doesn't store title, use sessionId
+                createdAt: new Date(session.createdAt).toISOString(),
+                updatedAt: new Date(session.lastActivity).toISOString(),
+                userId: session.userId,
+                messageCount: session.messages.length,
+                lastActive,
+            };
+        })
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     async clearSession(sessionId) {
         return withSpan({
             name: "neurolink.memory.clear",

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionListItem, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -175,6 +175,17 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * @returns Array of session metadata objects
      */
     getUserAllSessionsHistory(userId: string): Promise<SessionMetadata[]>;
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/neurolink.d.ts

@@ -14,6 +14,7 @@ import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { SkillsManager } from "./skills/skillsManager.js";
 import { TaskManager } from "./tasks/taskManager.js";
+import type { SessionExport, SessionListItem } from "./types/index.js";
 /**
  * Curator P2-4 dedup (concurrency-safe): native providers emit
  * `generation:end` on the shared SDK emitter. We attach a fresh
@@ -1631,6 +1632,32 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    exportSession(sessionId: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport | null>;
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    exportAllSessions(userId?: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport[]>;
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/lib/neurolink.js

@@ -10504,6 +10504,139 @@ Current user's request: ${currentInput}`;
         this.lastCompactionMessageCount.clear();
         await this.conversationMemory.clearAllSessions();
     }
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        // First ensure memory is initialized
+        const initId = `list-sessions-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        // Check if listSessions is available on the memory manager
+        if (!this.conversationMemory.listSessions) {
+            logger.warn("listSessions not available on current memory manager");
+            return [];
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const sessions = await withTimeout(this.conversationMemory.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            logger.debug("Listed conversation sessions", {
+                userId,
+                sessionCount: sessions.length,
+            });
+            return sessions;
+        }
+        catch (error) {
+            logger.error("Failed to list conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    async exportSession(sessionId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-session-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        if (!sessionId || typeof sessionId !== "string") {
+            throw new Error("Session ID must be a non-empty string");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const messages = await withTimeout(this.conversationMemory.buildContextMessages(sessionId), MEMORY_OPERATION_TIMEOUT, new Error("buildContextMessages operation timed out after 30s"));
+            if (messages.length === 0) {
+                logger.debug("No messages found for session export", { sessionId });
+                return null;
+            }
+            const sessionResult = this.conversationMemory.getSession(sessionId);
+            const session = await withTimeout(sessionResult instanceof Promise
+                ? sessionResult
+                : Promise.resolve(sessionResult), MEMORY_OPERATION_TIMEOUT, new Error("getSession operation timed out after 30s"));
+            const now = new Date().toISOString();
+            const exportData = {
+                sessionId,
+                title: sessionId, // Use sessionId as title if not available
+                userId: session?.userId,
+                createdAt: session?.createdAt
+                    ? new Date(session.createdAt).toISOString()
+                    : now,
+                updatedAt: session?.lastActivity
+                    ? new Date(session.lastActivity).toISOString()
+                    : now,
+                messages,
+            };
+            if (options.includeMetadata) {
+                exportData.exportMetadata = {
+                    exportedAt: now,
+                    exportFormat: options.format || "json",
+                };
+            }
+            logger.debug("Exported conversation session", {
+                sessionId,
+                messageCount: messages.length,
+            });
+            return exportData;
+        }
+        catch (error) {
+            logger.error("Failed to export conversation session", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    async exportAllSessions(userId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-all-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        const EXPORT_SESSION_TIMEOUT = 60000; // 60 seconds for full export
+        try {
+            // Get all session IDs
+            const sessions = await withTimeout(this.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            const exports = [];
+            for (const session of sessions) {
+                const exportData = await withTimeout(this.exportSession(session.id, options), EXPORT_SESSION_TIMEOUT, new Error(`exportSession operation timed out after 60s for session ${session.id}`));
+                if (exportData) {
+                    exports.push(exportData);
+                }
+            }
+            logger.debug("Exported all conversation sessions", {
+                userId,
+                sessionCount: exports.length,
+            });
+            return exports;
+        }
+        catch (error) {
+            logger.error("Failed to export all conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/lib/proxy/globalInstaller.d.ts

@@ -0,0 +1,5 @@
+import type { GlobalInstallerKind, GlobalInstallerResolution, ResolveGlobalInstallerOptions } from "../types/index.js";
+/** Resolve a package manager that can update the installation currently running. */
+export declare function resolveGlobalInstaller(options?: ResolveGlobalInstallerOptions): GlobalInstallerResolution;
+export declare function getGlobalInstallArgs(kind: GlobalInstallerKind, packageSpec: string): string[];
+export declare function describeInstallFailure(error: unknown): string;

package/dist/lib/proxy/globalInstaller.js

@@ -0,0 +1,156 @@
+import { execFileSync as nodeExecFileSync } from "node:child_process";
+import { accessSync, constants, existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+function runText(execFileSync, bin, args) {
+    return String(execFileSync(bin, args, {
+        encoding: "utf8",
+        timeout: 10_000,
+        stdio: ["ignore", "pipe", "pipe"],
+    })).trim();
+}
+function writableDirectory(path) {
+    try {
+        if (!existsSync(path)) {
+            return false;
+        }
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathInside(path, parent) {
+    if (!path) {
+        return false;
+    }
+    try {
+        const candidate = realpathSync(path);
+        const root = realpathSync(parent);
+        return candidate === root || candidate.startsWith(`${root}/`);
+    }
+    catch {
+        const candidate = resolve(path);
+        const root = resolve(parent);
+        return candidate === root || candidate.startsWith(`${root}/`);
+    }
+}
+function probeInstaller(kind, bin, entryScript, execFileSync) {
+    const base = {
+        kind,
+        bin,
+        working: false,
+        installable: false,
+        matchesCurrentInstall: false,
+    };
+    try {
+        base.version = runText(execFileSync, bin, ["--version"]);
+        base.working = base.version.length > 0;
+        base.globalRoot = runText(execFileSync, bin, ["root", "-g"]);
+        base.globalBinDir =
+            kind === "pnpm"
+                ? runText(execFileSync, bin, ["bin", "-g"])
+                : join(runText(execFileSync, bin, ["prefix", "-g"]), "bin");
+        if (!base.globalRoot || !writableDirectory(base.globalRoot)) {
+            base.reason = "global package root is missing or not writable";
+            return base;
+        }
+        if (!base.globalBinDir || !writableDirectory(base.globalBinDir)) {
+            base.reason = "global executable directory is missing or not writable";
+            return base;
+        }
+        base.installable = true;
+        base.matchesCurrentInstall = isPathInside(entryScript, base.globalRoot);
+        return base;
+    }
+    catch (error) {
+        base.reason = error instanceof Error ? error.message : String(error);
+        return base;
+    }
+}
+function resolveFromPath(command, execFileSync) {
+    try {
+        const result = runText(execFileSync, "which", [command]);
+        return result || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolve a package manager that can update the installation currently running. */
+export function resolveGlobalInstaller(options = {}) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const entryScript = options.entryScript ?? process.argv[1];
+    const execFileSync = options.execFileSync ?? nodeExecFileSync;
+    const candidates = [];
+    if (env.NEUROLINK_PACKAGE_MANAGER_PATH) {
+        const configuredKind = env.NEUROLINK_PACKAGE_MANAGER?.toLowerCase();
+        const inferredName = basename(env.NEUROLINK_PACKAGE_MANAGER_PATH);
+        const kind = configuredKind === "npm" || configuredKind === "pnpm"
+            ? configuredKind
+            : inferredName.startsWith("npm")
+                ? "npm"
+                : "pnpm";
+        candidates.push({ kind, bin: env.NEUROLINK_PACKAGE_MANAGER_PATH });
+    }
+    if (env.NEUROLINK_PNPM_PATH) {
+        candidates.push({ kind: "pnpm", bin: env.NEUROLINK_PNPM_PATH });
+    }
+    if (env.PNPM_HOME) {
+        candidates.push({ kind: "pnpm", bin: join(env.PNPM_HOME, "pnpm") });
+    }
+    const nodeBinDir = dirname(process.execPath);
+    candidates.push({ kind: "npm", bin: join(nodeBinDir, "npm") });
+    const pathPnpm = resolveFromPath("pnpm", execFileSync);
+    const pathNpm = resolveFromPath("npm", execFileSync);
+    if (pathPnpm) {
+        candidates.push({ kind: "pnpm", bin: pathPnpm });
+    }
+    if (pathNpm) {
+        candidates.push({ kind: "npm", bin: pathNpm });
+    }
+    candidates.push({ kind: "pnpm", bin: join(homeDir, ".local", "share", "pnpm", "pnpm") }, { kind: "pnpm", bin: join(homeDir, "Library", "pnpm", "pnpm") }, { kind: "npm", bin: "/opt/homebrew/bin/npm" }, { kind: "npm", bin: "/usr/local/bin/npm" });
+    const seen = new Set();
+    const tried = candidates
+        .filter(({ kind, bin }) => {
+        const key = `${kind}:${bin}`;
+        if (!bin || seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    })
+        .map(({ kind, bin }) => probeInstaller(kind, bin, entryScript, execFileSync));
+    const matchingInstaller = tried.find((probe) => probe.installable && probe.matchesCurrentInstall);
+    // When the running entry script is known, installing into a different
+    // global root cannot update that process and may shadow another install.
+    const installer = entryScript
+        ? matchingInstaller
+        : (matchingInstaller ?? tried.find((probe) => probe.installable));
+    return { installer, tried };
+}
+export function getGlobalInstallArgs(kind, packageSpec) {
+    return kind === "pnpm"
+        ? ["add", "-g", packageSpec]
+        : ["install", "--global", "--no-audit", "--no-fund", packageSpec];
+}
+function capturedOutput(error, key) {
+    if (!error || typeof error !== "object" || !(key in error)) {
+        return "";
+    }
+    const raw = error[key];
+    return String(raw ?? "")
+        .trim()
+        .slice(0, 1_000);
+}
+export function describeInstallFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stdout = capturedOutput(error, "stdout");
+    const stderr = capturedOutput(error, "stderr");
+    return [message, stdout && `stdout: ${stdout}`, stderr && `stderr: ${stderr}`]
+        .filter(Boolean)
+        .join("\n");
+}
+//# sourceMappingURL=globalInstaller.js.map

package/dist/lib/proxy/openaiFormat.d.ts

@@ -134,4 +134,6 @@ export declare function convertClaudeToOpenAIResponse(claude: ClaudeResponse, re
  *  - message_delta       -> captures stop_reason and output token usage
  *  - message_stop        -> emits the final `finish_reason` chunk + `[DONE]`
  */
-export declare function createClaudeToOpenAIStreamTransform(requestModel: string): TransformStream<Uint8Array, Uint8Array>;
+export declare function createClaudeToOpenAIStreamTransform(requestModel: string, options?: {
+    onError?: (message: string) => void;
+}): TransformStream<Uint8Array, Uint8Array>;