@voidrun/sdk 0.0.17 → 0.0.18

package/dist/CodeInterpreter.d.ts

@@ -1,77 +1,57 @@
 import { Configuration } from './api-client/index.js';
-export type SupportedLanguage = 'python' | 'javascript' | 'node' | 'bash' | 'go' | 'ruby' | 'java' | 'csharp';
+export type SupportedLanguage = 'python' | 'javascript' | 'typescript' | 'node' | 'bash' | 'sh';
 export interface CodeExecutionOptions {
+    language?: SupportedLanguage;
     timeout?: number;
     cwd?: string;
     env?: Record<string, string>;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    onError?: (error: Error) => void;
 }
 export interface CodeExecutionResult {
     success: boolean;
-    output: string;
+    results: any;
+    stdout: string;
+    stderr: string;
     error?: string;
     exitCode?: number;
+    logs: {
+        stdout: string[];
+        stderr: string[];
+    };
 }
 /**
- * CodeInterpreter provides a simple API to execute code in various languages
- * over a PTY session, similar to e2b or Daytona
+ * CodeInterpreter provides E2B-style code execution API
+ * Executes code snippets in different languages with streaming support
  */
 export declare class CodeInterpreter {
     private sandboxId;
     private config;
-    private ptySession;
-    private currentLanguage;
-    private isInitialized;
-    private readonly languageConfigs;
+    private execApi;
     /**
      * @internal
      */
     constructor(sandboxId: string, config: Configuration);
     /**
-     * Initialize the code interpreter with a specific language
-     * @param language The programming language to use
-     * @param sessionId Optional existing PTY session ID
-     */
-    initialize(language: SupportedLanguage, sessionId?: string): Promise<void>;
-    /**
-     * Execute code in the initialized interpreter
+     * Execute code and return results (E2B-style API)
      * @param code The code to execute
-     * @param options Execution options
-     * @returns The execution result
-     */
-    execute(code: string, options?: CodeExecutionOptions): Promise<CodeExecutionResult>;
-    /**
-     * Execute multiple code snippets sequentially
-     * @param codeSnippets Array of code snippets to execute
-     * @param options Execution options
-     * @returns Array of execution results
-     */
-    executeMultiple(codeSnippets: string[], options?: CodeExecutionOptions): Promise<CodeExecutionResult[]>;
-    /**
-     * Execute code from a file
-     * @param filePath Path to the file containing code
-     * @param options Execution options
-     * @returns The execution result
-     */
-    executeFile(filePath: string, options?: CodeExecutionOptions): Promise<CodeExecutionResult>;
-    /**
-     * Get the current language
-     */
-    getCurrentLanguage(): SupportedLanguage | null;
-    /**
-     * Check if interpreter is initialized
+     * @param options Execution options including language and handlers
+     * @returns Execution result with stdout, stderr, and parsed results
      */
-    isReady(): boolean;
+    runCode(code: string, options?: CodeExecutionOptions): Promise<CodeExecutionResult>;
     /**
-     * Clean up the interpreter session
+     * Execute code with streaming handlers
      */
-    close(): Promise<void>;
+    private executeStreaming;
     /**
-     * Reset the interpreter for a new language
+     * Build execution command for the given language
      */
-    reset(newLanguage?: SupportedLanguage): Promise<void>;
+    private buildCommand;
     /**
-     * Clean output by removing the input command and extra prompts
+     * Parse execution results from output
+     * Tries to extract the last expression result for REPLs
      */
-    private cleanOutput;
+    private parseResults;
 }
 //# sourceMappingURL=CodeInterpreter.d.ts.map

package/dist/CodeInterpreter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodeInterpreter.d.ts","sourceRoot":"","sources":["../src/CodeInterpreter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9G,MAAM,WAAW,oBAAoB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAWD;;;GAGG;AACH,qBAAa,eAAe;IAoEpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IApElB,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,aAAa,CAAkB;IAEvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAyD9B;IAEF;;OAEG;gBAES,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,aAAa;IAGjC;;;;OAIG;IACG,UAAU,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2ChF;;;;;OAKG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4F7F;;;;;OAKG;IACG,eAAe,CACjB,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,GAAE,oBAAyB,GACnC,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAQjC;;;;;OAKG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAuBrG;;OAEG;IACH,kBAAkB,IAAI,iBAAiB,GAAG,IAAI;IAI9C;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;OAEG;IACG,KAAK,CAAC,WAAW,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3D;;OAEG;IACH,OAAO,CAAC,WAAW;CA2DtB"}
+{"version":3,"file":"CodeInterpreter.d.ts","sourceRoot":"","sources":["../src/CodeInterpreter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,uBAAuB,CAAC;AAGjF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,YAAY,GAAG,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAEhG,MAAM,WAAW,oBAAoB;IACjC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE;QACF,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,MAAM,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACL;AAED;;;GAGG;AACH,qBAAa,eAAe;IAOpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAPlB,OAAO,CAAC,OAAO,CAAe;IAE9B;;OAEG;gBAES,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,aAAa;IAKjC;;;;;OAKG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA8D7F;;OAEG;YACW,gBAAgB;IA6F9B;;OAEG;IACH,OAAO,CAAC,YAAY;IA2CpB;;;OAGG;IACH,OAAO,CAAC,YAAY;CAoBvB"}

package/dist/CodeInterpreter.js

@@ -1,323 +1,231 @@
+import { ExecutionApi } from './api-client/index.js';
+import { wrapRequest } from './utils/runtime.js';
 /**
- * CodeInterpreter provides a simple API to execute code in various languages
- * over a PTY session, similar to e2b or Daytona
+ * CodeInterpreter provides E2B-style code execution API
+ * Executes code snippets in different languages with streaming support
  */
 export class CodeInterpreter {
     sandboxId;
     config;
-    ptySession = null;
-    currentLanguage = null;
-    isInitialized = false;
-    languageConfigs = {
-        python: {
-            command: 'python',
-            interactivePrompt: /(?:>>>|\.\.\.) $/,
-            startScript: '',
-            endScript: '',
-            timeout: 30000,
-        },
-        javascript: {
-            command: 'node',
-            interactivePrompt: /(?:^|\n)(?:>|\.\.\.) $/,
-            startScript: '',
-            endScript: '',
-            timeout: 30000,
-        },
-        node: {
-            command: 'node',
-            interactivePrompt: /(?:^|\n)(?:>|\.\.\.) $/,
-            startScript: '',
-            endScript: '',
-            timeout: 30000,
-        },
-        bash: {
-            command: 'bash',
-            interactivePrompt: /[$#] $/,
-            startScript: '',
-            endScript: '',
-            timeout: 30000,
-        },
-        go: {
-            command: 'go run',
-            interactivePrompt: /^[\s\S]*$/,
-            startScript: '',
-            endScript: '',
-            timeout: 30000,
-        },
-        ruby: {
-            command: 'irb',
-            interactivePrompt: 'irb(main):',
-            startScript: '',
-            endScript: 'exit',
-            timeout: 30000,
-        },
-        java: {
-            command: 'jshell',
-            interactivePrompt: 'jshell>',
-            startScript: '',
-            endScript: '/exit',
-            timeout: 30000,
-        },
-        csharp: {
-            command: 'csharp',
-            interactivePrompt: 'csharp> ',
-            startScript: '',
-            endScript: 'exit;',
-            timeout: 30000,
-        },
-    };
+    execApi;
     /**
      * @internal
      */
     constructor(sandboxId, config) {
         this.sandboxId = sandboxId;
         this.config = config;
+        this.execApi = new ExecutionApi(config);
     }
     /**
-     * Initialize the code interpreter with a specific language
-     * @param language The programming language to use
-     * @param sessionId Optional existing PTY session ID
+     * Execute code and return results (E2B-style API)
+     * @param code The code to execute
+     * @param options Execution options including language and handlers
+     * @returns Execution result with stdout, stderr, and parsed results
      */
-    async initialize(language, sessionId) {
-        if (this.isInitialized && this.currentLanguage === language) {
-            return;
-        }
-        if (!this.languageConfigs[language]) {
-            throw new Error(`Unsupported language: ${language}`);
+    async runCode(code, options = {}) {
+        const language = options.language || 'python';
+        const timeout = options.timeout || 60;
+        const { onStdout, onStderr, onError } = options;
+        // Build the execution command based on language
+        const { command, tempFile } = this.buildCommand(code, language);
+        const stdoutLines = [];
+        const stderrLines = [];
+        let exitCode = 0;
+        let hasError = false;
+        // Use streaming execution if handlers are provided
+        if (onStdout || onStderr || onError) {
+            await this.executeStreaming(command, timeout, options, stdoutLines, stderrLines);
         }
-        this.currentLanguage = language;
-        const langConfig = this.languageConfigs[language];
-        // Create or connect to PTY session
-        const PTY = (await import('./PTY.js')).PTY;
-        const ptyManager = new PTY(this.sandboxId, this.config);
-        let session;
-        if (!sessionId) {
-            session = await ptyManager.createSession();
-            sessionId = session.data?.sessionId;
-        }
-        this.ptySession = await ptyManager.connect({
-            sessionId,
-            onData: () => { }, // Will be overridden when needed
-        });
-        // Start the interpreter
-        let initPrompt = langConfig.interactivePrompt;
-        // For JavaScript/Node, use a simpler prompt match that works with ANSI codes
-        if (this.currentLanguage === 'javascript' || this.currentLanguage === 'node') {
-            initPrompt = /> /;
+        else {
+            // Non-streaming execution
+            try {
+                const result = await wrapRequest(this.execApi.execCommand({
+                    id: this.sandboxId,
+                    execRequest: {
+                        command,
+                        timeout,
+                        cwd: options.cwd,
+                        env: options.env,
+                    }
+                }));
+                if (result.data) {
+                    stdoutLines.push(result.data.stdout || '');
+                    stderrLines.push(result.data.stderr || '');
+                    exitCode = result.data.exitCode || 0;
+                }
+            }
+            catch (error) {
+                hasError = true;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                stderrLines.push(errorMsg);
+                (options.onError ?? (() => { }))(error instanceof Error ? error : new Error(errorMsg));
+            }
         }
-        await this.ptySession.runCommand(langConfig.command, {
-            prompt: initPrompt,
-            timeout: langConfig.timeout,
-        });
-        this.isInitialized = true;
+        const stdout = stdoutLines.join('');
+        const stderr = stderrLines.join('');
+        // Parse results from stdout
+        const results = this.parseResults(stdout, language);
+        return {
+            success: exitCode === 0 && !hasError,
+            results,
+            stdout,
+            stderr,
+            error: stderr || undefined,
+            exitCode,
+            logs: {
+                stdout: stdoutLines,
+                stderr: stderrLines,
+            }
+        };
     }
     /**
-     * Execute code in the initialized interpreter
-     * @param code The code to execute
-     * @param options Execution options
-     * @returns The execution result
+     * Execute code with streaming handlers
      */
-    async execute(code, options = {}) {
-        if (!this.isInitialized || !this.ptySession || !this.currentLanguage) {
-            throw new Error('Interpreter not initialized. Call initialize() first.');
+    async executeStreaming(command, timeout, options, stdoutLines, stderrLines) {
+        const fetchApi = this.config.fetchApi ?? fetch;
+        const headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        };
+        if (this.config.apiKey) {
+            headers['X-API-Key'] = await this.config.apiKey('X-API-Key');
         }
-        const timeout = options.timeout || this.languageConfigs[this.currentLanguage].timeout || 30000;
-        let prompt = this.languageConfigs[this.currentLanguage].interactivePrompt;
+        const url = `${this.config.basePath}/sandboxes/${this.sandboxId}/exec-stream`;
+        const execRequest = {
+            command,
+            timeout,
+            cwd: options.cwd,
+            env: options.env,
+        };
         try {
-            let trimmedCode = code.trim();
-            let allOutput = '';
-            // For Node.js REPL with multi-line statements
-            if (this.currentLanguage === 'javascript' || this.currentLanguage === 'node') {
-                prompt = /> /;
-                // If it's multi-line code, split and execute line by line for better compatibility
-                if (trimmedCode.includes('\n')) {
-                    const lines = trimmedCode.split('\n');
-                    let bracketCount = 0;
-                    let statementBuffer = '';
-                    const statements = [];
+            const response = await fetchApi(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(execRequest),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(text || `Exec failed with status ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error('Response has no body');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder('utf-8');
+            let buffer = '';
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split('\n\n');
+                buffer = parts.pop() || '';
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    let event = 'message';
+                    const dataLines = [];
                     for (const line of lines) {
-                        const trimmedLine = line.trim();
-                        // Track braces to detect complete statements
-                        bracketCount += (trimmedLine.match(/{/g) || []).length;
-                        bracketCount -= (trimmedLine.match(/}/g) || []).length;
-                        statementBuffer += (statementBuffer ? '\n' : '') + line;
-                        // If braces are balanced and line is not empty, we may have a complete statement
-                        if (bracketCount === 0 && trimmedLine && !trimmedLine.endsWith('{')) {
-                            // Check if this looks like a complete statement
-                            if (trimmedLine.endsWith(';') ||
-                                trimmedLine.endsWith(')') ||
-                                trimmedLine === '}' ||
-                                trimmedLine.match(/^return\s/) ||
-                                bracketCount < 0) {
-                                statements.push(statementBuffer.trim());
-                                statementBuffer = '';
-                                bracketCount = 0;
-                            }
+                        if (line.startsWith('event:')) {
+                            event = line.slice(6).trim();
                         }
+                        else if (line.startsWith('data:')) {
+                            dataLines.push(line.slice(5).trimEnd());
+                        }
+                    }
+                    const data = dataLines.join('\n');
+                    if (!data)
+                        continue;
+                    if (event === 'stdout') {
+                        stdoutLines.push(data);
+                        options.onStdout?.(data);
                     }
-                    // Add any remaining code
-                    if (statementBuffer.trim()) {
-                        statements.push(statementBuffer.trim());
+                    else if (event === 'stderr') {
+                        stderrLines.push(data);
+                        options.onStderr?.(data);
                     }
-                    // Execute each statement and collect output
-                    for (const stmt of statements) {
+                    else if (event === 'exit') {
                         try {
-                            const output = await this.ptySession.runCommand(stmt, {
-                                prompt,
-                                timeout,
-                            });
-                            allOutput += (allOutput ? '\n' : '') + output;
+                            const exitData = JSON.parse(data);
+                            // Store exit code if needed
                         }
                         catch (err) {
-                            // Continue with next statement even if one fails
-                            allOutput += (allOutput ? '\n' : '') + String(err);
+                            // Ignore parse errors
                         }
                     }
-                    return {
-                        success: true,
-                        output: this.cleanOutput(allOutput, trimmedCode),
-                    };
                 }
             }
-            const output = await this.ptySession.runCommand(trimmedCode, {
-                prompt,
-                timeout,
-            });
-            return {
-                success: true,
-                output: this.cleanOutput(output, trimmedCode),
-            };
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                output: '',
-                error: errorMessage,
-            };
+            if (options.onError) {
+                options.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+            throw error;
         }
     }
     /**
-     * Execute multiple code snippets sequentially
-     * @param codeSnippets Array of code snippets to execute
-     * @param options Execution options
-     * @returns Array of execution results
+     * Build execution command for the given language
      */
-    async executeMultiple(codeSnippets, options = {}) {
-        const results = [];
-        for (const code of codeSnippets) {
-            results.push(await this.execute(code, options));
+    buildCommand(code, language) {
+        const timestamp = Date.now();
+        switch (language) {
+            case 'python': {
+                // For Python, use -c for short snippets, temp file for longer code
+                if (code.length < 1000 && !code.includes('\n\n')) {
+                    // Escape single quotes and use python -c
+                    const escapedCode = code.replace(/'/g, "'\\''");
+                    return { command: `python3 -c '${escapedCode}'` };
+                }
+                else {
+                    // Write to temp file for complex code
+                    const tempFile = `/tmp/code_${timestamp}.py`;
+                    const writeCmd = `cat > ${tempFile} << 'EOFPYTHON'\n${code}\nEOFPYTHON`;
+                    return {
+                        command: `${writeCmd} && python3 ${tempFile} && rm -f ${tempFile}`,
+                        tempFile
+                    };
+                }
+            }
+            case 'javascript':
+            case 'node':
+            case 'typescript': {
+                const tempFile = `/tmp/code_${timestamp}.js`;
+                const writeCmd = `cat > ${tempFile} << 'EOFJS'\n${code}\nEOFJS`;
+                return {
+                    command: `${writeCmd} && node ${tempFile} && rm -f ${tempFile}`,
+                    tempFile
+                };
+            }
+            case 'bash':
+            case 'sh': {
+                const escapedCode = code.replace(/'/g, "'\\''");
+                return { command: `bash -c '${escapedCode}'` };
+            }
+            default:
+                throw new Error(`Unsupported language: ${language}`);
         }
-        return results;
     }
     /**
-     * Execute code from a file
-     * @param filePath Path to the file containing code
-     * @param options Execution options
-     * @returns The execution result
+     * Parse execution results from output
+     * Tries to extract the last expression result for REPLs
      */
-    async executeFile(filePath, options = {}) {
-        if (!this.ptySession) {
-            throw new Error('Interpreter not initialized');
+    parseResults(output, language) {
+        if (!output || !output.trim()) {
+            return null;
         }
+        // For Python/Node REPL-style output, try to get the last value
+        const lines = output.trim().split('\n');
+        const lastLine = lines[lines.length - 1];
+        // Try to parse as JSON first
         try {
-            // Read the file first using FS operations
-            const FS = (await import('./FS.js')).FS;
-            const fsManager = new FS(this.sandboxId, this.config);
-            const buffer = await fsManager.downloadFile(filePath);
-            const content = buffer.toString('utf-8');
-            return await this.execute(content, options);
+            return JSON.parse(lastLine);
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                output: '',
-                error: errorMessage,
-            };
-        }
-    }
-    /**
-     * Get the current language
-     */
-    getCurrentLanguage() {
-        return this.currentLanguage;
-    }
-    /**
-     * Check if interpreter is initialized
-     */
-    isReady() {
-        return this.isInitialized;
-    }
-    /**
-     * Clean up the interpreter session
-     */
-    async close() {
-        if (this.ptySession) {
-            this.ptySession.close();
-            this.ptySession = null;
-        }
-        this.isInitialized = false;
-        this.currentLanguage = null;
-    }
-    /**
-     * Reset the interpreter for a new language
-     */
-    async reset(newLanguage) {
-        await this.close();
-        if (newLanguage) {
-            await this.initialize(newLanguage);
-        }
-    }
-    /**
-     * Clean output by removing the input command and extra prompts
-     */
-    cleanOutput(output, input) {
-        let cleaned = output;
-        // Remove ANSI escape codes
-        cleaned = cleaned.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
-        // Remove carriage returns
-        cleaned = cleaned.replace(/\r/g, '');
-        // Split into lines
-        const lines = cleaned.split('\n');
-        const inputLines = input.split('\n').map(l => l.trim());
-        // Find all actual output lines (not prompts, not input echoes, not continuation indicators)
-        const outputLines = [];
-        for (const line of lines) {
-            const trimmed = line.trim();
-            // Skip empty lines
-            if (!trimmed) {
-                continue;
-            }
-            // Skip prompts
-            if (trimmed.match(/^(?:>>>|\.\.\.|\$|#|>)$/)) {
-                continue;
-            }
-            // Skip Node.js continuation indicators (lines starting with |)
-            if (trimmed.startsWith('|')) {
-                continue;
-            }
-            // Skip input echo lines
-            let isInputEcho = false;
-            for (const inputLine of inputLines) {
-                if (inputLine && trimmed === inputLine) {
-                    isInputEcho = true;
-                    break;
-                }
-            }
-            if (!isInputEcho) {
-                // Remove trailing prompts from lines
-                const cleanedLine = trimmed
-                    .replace(/>>>\s*$/, '')
-                    .replace(/\.\.\.\s*$/, '')
-                    .replace(/>\s*$/, '')
-                    .replace(/[$#]\s*$/, '');
-                if (cleanedLine) {
-                    outputLines.push(cleanedLine);
-                }
+        catch {
+            // If not JSON, return the last line or full output
+            if (lastLine && lastLine !== 'undefined' && lastLine !== 'None') {
+                return lastLine;
             }
+            return output.trim();
         }
-        return outputLines.join('\n').trim();
     }
 }
 //# sourceMappingURL=CodeInterpreter.js.map