Skip to content

🎥 Make videos programmatically with React

Add current error to Studio WebMCP

Jonny Burger6a9bfc68b716
diff --git a/packages/example/e2e/error-overlay.test.mts b/packages/example/e2e/error-overlay.test.mts
index 2a1987d766..b1c944cd90 100644
--- a/packages/example/e2e/error-overlay.test.mts
+++ b/packages/example/e2e/error-overlay.test.mts
@@ -119,7 +119,44 @@ test.describe('error overlay dismissal', () => {
});
await page.addInitScript(() => {
Object.defineProperty(window.navigator, 'platform', {value: 'Win32'});
+ type RegisteredTool = {
+ readonly name: string;
+ readonly execute: (input: Record<string, unknown>) => Promise<unknown>;
+ };
+ const tools = new Map<string, RegisteredTool>();
+ Object.defineProperty(window, '__remotion_webmcp_tools', {
+ value: tools,
+ });
+ Object.defineProperty(document, 'modelContext', {
+ value: {
+ registerTool: async (
+ tool: RegisteredTool,
+ options: {readonly signal: AbortSignal},
+ ) => {
+ tools.set(tool.name, tool);
+ options.signal.addEventListener('abort', () => {
+ if (tools.get(tool.name) === tool) {
+ tools.delete(tool.name);
+ }
+ });
+ },
+ },
+ });
});
+ const getCurrentError = () => {
+ return page.evaluate(async () => {
+ const tools = (
+ window as typeof window & {
+ readonly __remotion_webmcp_tools: Map<
+ string,
+ {readonly execute: () => Promise<unknown>}
+ >;
+ }
+ ).__remotion_webmcp_tools;
+ const tool = tools.get('get_current_error');
+ return tool ? tool.execute() : 'not-registered';
+ });
+ };
await page.goto(`${STUDIO_URL}/error-overlay-unsymbolicated-e2e`);
await expect(page.getByText('Expected defaults').first()).toBeVisible({
timeout: 15_000,
@@ -246,6 +283,14 @@ test.describe('error overlay dismissal', () => {
(element) => element.scrollWidth > element.clientWidth,
),
).toBe(true);
+ await expect.poll(getCurrentError).toEqual({
+ name: 'TypeError',
+ message: 'Expected defaults',
+ stack: expect.stringContaining(
+ 'webpack-internal:///cannot-symbolicate.js',
+ ),
+ symbolicatedStackFrames: null,
+ });
await page.getByRole('button', {name: 'Copy stack'}).click();
await expect(page.getByRole('button', {name: 'Copied!'})).toBeVisible();
@@ -258,6 +303,7 @@ test.describe('error overlay dismissal', () => {
// Sanity check: no error visible initially.
await expect(errorMessage).toHaveCount(0);
+ await expect.poll(getCurrentError).toBe(null);
// 1. Introduce the bug: remove the `radius: 24` argument.
await writeAndWaitForRebuild(buggyContent, 'introducing the bug');
@@ -265,6 +311,19 @@ test.describe('error overlay dismissal', () => {
await expect(
page.getByText('ErrorOverlayRepro', {exact: true}),
).toBeVisible();
+ await expect.poll(getCurrentError).toEqual({
+ name: 'TypeError',
+ message: '"radius" must be a finite number, but got undefined',
+ stack: expect.any(String),
+ symbolicatedStackFrames: expect.arrayContaining([
+ expect.objectContaining({
+ originalFunctionName: 'ErrorOverlayRepro',
+ originalFileName: expect.stringContaining(
+ 'src/ErrorOverlayE2e/ErrorOverlayRepro.tsx',
+ ),
+ }),
+ ]),
+ });
await expect(
page.getByText('react_stack_bottom_frame', {exact: true}),
).toHaveCount(0);
@@ -333,6 +392,7 @@ test.describe('error overlay dismissal', () => {
// dismiss once HMR applies the fix.
await writeAndWaitForRebuild(originalContent, 'fixing the bug');
await expect(errorMessage).toHaveCount(0, {timeout: 15_000});
+ await expect.poll(getCurrentError).toBe(null);
// 3. Re-introduce the bug: the error UI should come back. This guards
// against the boundary getting permanently stuck in the success state
diff --git a/packages/studio/src/components/WebMcp.tsx b/packages/studio/src/components/WebMcp.tsx
index 5132946e60..6e20498cf9 100644
--- a/packages/studio/src/components/WebMcp.tsx
+++ b/packages/studio/src/components/WebMcp.tsx
@@ -3,6 +3,7 @@ import {Internals} from 'remotion';
import {pause} from '../api/pause';
import {play} from '../api/play';
import {seek} from '../api/seek';
+import {getCurrentError} from '../error-overlay/current-error';
import {calculateTimeline} from '../helpers/calculate-timeline';
import {createFolderTree} from '../helpers/create-folder-tree';
import {
@@ -296,6 +297,42 @@ export const WebMcp: FC = () => {
};
Promise.all([
+ modelContext.registerTool(
+ {
+ name: 'get_current_error',
+ title: 'Get current Studio error',
+ description:
+ 'Read the error currently shown in the Remotion Studio error overlay. Returns null when the overlay is not visible and includes symbolicated stack frames when symbolication succeeds.',
+ inputSchema: {
+ type: 'object',
+ properties: {},
+ additionalProperties: false,
+ },
+ annotations: {readOnlyHint: true},
+ execute: async () => {
+ const currentError = getCurrentError();
+ if (currentError === null) {
+ return null;
+ }
+
+ let symbolicatedStackFrames = null;
+ try {
+ const record = await currentError.symbolication;
+ symbolicatedStackFrames = record?.stackFrames ?? null;
+ } catch {
+ // Fall back to the original stack if symbolication fails.
+ }
+
+ return {
+ name: currentError.error.name,
+ message: currentError.error.message,
+ stack: currentError.error.stack ?? null,
+ symbolicatedStackFrames,
+ };
+ },
+ },
+ {signal: controller.signal},
+ ),
modelContext.registerTool(
{
name: 'get_compositions',
diff --git a/packages/studio/src/error-overlay/current-error.ts b/packages/studio/src/error-overlay/current-error.ts
new file mode 100644
index 0000000000..784b9b23ed
--- /dev/null
+++ b/packages/studio/src/error-overlay/current-error.ts
@@ -0,0 +1,29 @@
+import type {ErrorRecord} from './react-overlay/listen-to-runtime-errors';
+
+type CurrentError = {
+ readonly error: Error;
+ readonly symbolication: Promise<ErrorRecord | null>;
+};
+
+declare global {
+ interface Window {
+ remotion_currentErrors: CurrentError[] | undefined;
+ }
+}
+
+export const registerCurrentError = (error: CurrentError) => {
+ window.remotion_currentErrors = [
+ ...(window.remotion_currentErrors ?? []),
+ error,
+ ];
+
+ return () => {
+ window.remotion_currentErrors = window.remotion_currentErrors?.filter(
+ (candidate) => candidate !== error,
+ );
+ };
+};
+
+export const getCurrentError = (): CurrentError | null => {
+ return window.remotion_currentErrors?.[0] ?? null;
+};
diff --git a/packages/studio/src/error-overlay/remotion-overlay/ErrorLoader.tsx b/packages/studio/src/error-overlay/remotion-overlay/ErrorLoader.tsx
index 1472d2c255..c9a136c838 100644
--- a/packages/studio/src/error-overlay/remotion-overlay/ErrorLoader.tsx
+++ b/packages/studio/src/error-overlay/remotion-overlay/ErrorLoader.tsx
@@ -1,5 +1,6 @@
import {getLocationFromBuildError} from '@remotion/studio-shared';
import React, {useEffect, useState} from 'react';
+import {registerCurrentError} from '../current-error';
import {wasErrorLoggedByServer} from '../error-origin';
import type {ErrorRecord} from '../react-overlay/listen-to-runtime-errors';
import {getErrorRecord} from '../react-overlay/listen-to-runtime-errors';
@@ -93,7 +94,9 @@ export const ErrorLoader: React.FC<{
});
useEffect(() => {
- getErrorRecord(error)
+ const symbolication = getErrorRecord(error);
+ const unregister = registerCurrentError({error, symbolication});
+ symbolication
.then((record) => {
if (record) {
if (shouldLogError(error)) {
@@ -124,6 +127,8 @@ export const ErrorLoader: React.FC<{
type: 'error',
});
});
+
+ return unregister;
}, [error]);
if (state.type === 'loading') {