Make `onOutput` behavior consistent in `positron.runtime.executeCode` between R and Python

[kv9898]

System details:

Positron and OS details:

Windows 11

Session details:

Positron Version: 2025.12.0 (system setup) build 35
Code - OSS Version: 1.105.0
Commit: 5418e79
Date: 2025-11-06T07:36:41.761Z
Electron: 37.6.0
Chromium: 138.0.7204.251
Node.js: 22.19.0
V8: 13.8.258.32-electron.0
OS: Windows_NT x64 10.0.26100

Describe the issue:

Summary

Currently, positron.runtime.executeCode supports an observer that receives error messages when code execution fails, but it doesn’t return standard output when the code completes successfully. This makes it difficult for extensions or clients to capture the printed output of executed code directly.

Motivation / Problem

At present, the only way to access printed output is by writing to a temporary file and reading it back. This workaround is cumbersome and introduces unnecessary I/O overhead and potential race conditions. For example, an extension that runs snippets to produce lightweight feedback or inline results must handle file writes, file cleanup, and synchronization — all of which could be avoided if executeCode exposed stdout.

Proposed Solution

Extend the observer interface to include a callback or event for standard output. For example:

positron.runtime.executeCode(code, ..., {
  onOutput: (text) => { /* handle printed output */ },
  onError: (err) => { /* handle errors */ },
  onComplete: () => { /* handle completion */ },
  ...
});

This would parallel the existing error reporting mechanism and make it much easier to build extensions that need to capture or display output dynamically.

Benefits

• Enables extensions to display code output inline without temp files.
• Reduces file system operations and improves performance.
• Aligns with common patterns in REPL- or notebook-style APIs (e.g., Jupyter, Node.js child_process).
• Simplifies extension development and debugging.

Alternatives Considered

Using temporary files works, but it is an ugly and brittle solution compared to an API-level event.

Steps to reproduce the issue:

Expected or desired behavior:

Were there any error messages in the UI, Output panel, or Developer Tools console?

[midleman]

Thanks for this detailed feature request! The proposed enhancement to positron.runtime.executeCode makes a lot of sense.

Related context: This is related to #7569, which discusses how executeCode currently handles output inconsistently (using result vs outputText fields depending on context). While that issue focuses on the Assistant tool's result structure, your request addresses the broader need for extension developers to access stdout programmatically via the observer API.

I'll move this along to triage, so the team can evaluate. Thanks again!

[jmcphers]

Extend the observer interface to include a callback or event for standard output. For example:

onOutput: (text) => { /* handle printed output */ },

This already exists, and it should work!

positron/src/positron-dts/positron.d.ts

Lines 1727 to 1734 in e15fb1e

	/**
	* An optional callback to invoke when the execution emits text
	* output. This can be called zero or more times during execution of
	* the code.
	*
	* @param message The message emitted.
	*/
	onOutput?: (message: string) => void;

If you are not seeing it work, could you

• tell us if it works with a simple example such as cat("hello there!\n")
• share an example of the code that is emitting output that doesn't get picked up by onOutput

[kv9898]

@jmcphers Ahh thank you for pointing this out to me, may be I should rephrase my original issue:

onOutput doesn't work for silent mode - it certainly works for interactive!

[juliasilge]

My understanding is that the idea of RuntimeCodeExecutionMode.Silent is that there is no text output emitted. Maybe you can say more about what you are thinking here?

[kv9898]

My understanding is that the idea of RuntimeCodeExecutionMode.Silent is that there is no text output emitted. Maybe you can say more about what you are thinking here?

My use case is for my R package manager extension (and I know a few other extensions have the same problem):
https://github.com/kv9898/positron-r-package-manager

We need info about the current R session. We don't want to run 'interactive' code to disturb our users but need output from the R console (e.g., which packages are available/loaded). Currently, we seem to have to rely on tempfile writing.

[kv9898]

@juliasilge I just realised this is an issue of incoherent language runtime behaviour:

sample extension code to test:

import * as vscode from 'vscode';
import { tryAcquirePositronApi } from '@posit-dev/positron';

export function activate(context: vscode.ExtensionContext) {
	const disposable = vscode.commands.registerCommand('positron-api-tester.testOnOutput', () => {
		const positron = tryAcquirePositronApi();

		if (positron) {
			positron.runtime.executeCode('r', 'print("Hello from Positron!")', false, undefined, // can be changed to `python`
				positron.RuntimeCodeExecutionMode.Silent, undefined, {
				onOutput: (output) => {
					vscode.window.showInformationMessage(`Output from Positron: ${output}`);
				}
			});
		} else {
			vscode.window.showInformationMessage('Hello from VS Code!');
		}
	});
}

• With R, nothing is printed to console or shown as information messages
• With Python, the code is not printed, but output is printed to both the console and as an information message