Support raw MCP content blocks from execute

packages/worker/src/mcp/executor.node.test.ts

@@ -1,11 +1,16 @@
 import { expect, test } from 'vitest'
+import { type ContentBlock } from '@modelcontextprotocol/sdk/types.js'
 import {
 	createCapabilitySecretAccessDeniedBatchMessage,
 	createCapabilitySecretAccessDeniedMessage,
 	createHostSecretAccessDeniedBatchMessage,
 	createMissingSecretMessage,
 } from '#mcp/secrets/errors.ts'
-import { formatExecutionOutput, getExecutionErrorDetails } from './executor.ts'
+import {
+	extractRawContent,
+	formatExecutionOutput,
+	getExecutionErrorDetails,
+} from './executor.ts'
 
 test('getExecutionErrorDetails returns concrete guidance for capability access denial', () => {
 	const error = new Error(
@@ -59,6 +64,32 @@ test('formatExecutionOutput keeps missing secret guidance intact', () => {
 	)
 })
 
+test('extractRawContent returns MCP content blocks from sentinel result', () => {
+	const content: Array<ContentBlock> = [
+		{
+			type: 'image',
+			data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB',
+			mimeType: 'image/png',
+		},
+		{
+			type: 'text',
+			text: 'Screenshot of https://example.com',
+		},
+	]
+
+	expect(
+		extractRawContent({
+			__mcpContent: content,
+		}),
+	).toEqual(content)
+})
+
+test('extractRawContent returns null for non-sentinel values', () => {
+	expect(extractRawContent({ result: 'not raw content' })).toBeNull()
+	expect(extractRawContent('plain text')).toBeNull()
+	expect(extractRawContent(null)).toBeNull()
+})
+
 test('getExecutionErrorDetails returns batch capability approvals', () => {
 	const error = new Error(
 		createCapabilitySecretAccessDeniedBatchMessage([

packages/worker/src/mcp/executor.ts

@@ -1,4 +1,5 @@
 import { DynamicWorkerExecutor, type ExecuteResult } from '@cloudflare/codemode'
+import { type ContentBlock } from '@modelcontextprotocol/sdk/types.js'
 import { exports as workerExports } from 'cloudflare:workers'
 type WorkerLoopbackExports = Exclude<typeof workerExports, undefined>
 import { type FetchGatewayProps } from '#mcp/fetch-gateway.ts'
@@ -212,6 +213,18 @@ export function formatExecutionOutput(result: ExecuteResult) {
 	return truncateExecutionResult(result.result)
 }
 
+export function extractRawContent(value: unknown): Array<ContentBlock> | null {
+	if (
+		typeof value === 'object' &&
+		value !== null &&
+		'__mcpContent' in value &&
+		Array.isArray((value as { __mcpContent: unknown }).__mcpContent)
+	) {
+		return (value as { __mcpContent: Array<ContentBlock> }).__mcpContent
+	}
+	return null
+}
+
 function stringifyExecutionError(error: unknown) {
 	return error instanceof Error ? error.message : String(error)
 }

packages/worker/src/mcp/tools/execute.node.test.ts

@@ -1,15 +1,43 @@
-import { expect, test, vi } from 'vitest'
-import { registerExecuteTool } from './execute.ts'
+import { type ContentBlock } from '@modelcontextprotocol/sdk/types.js'
+import { beforeEach, expect, test, vi } from 'vitest'
 
-test('registers execute tool', async () => {
+const mockModule = vi.hoisted(() => ({
+	runCodemodeWithRegistry: vi.fn(),
+	getCapabilityRegistryForContext: vi.fn(async () => ({
+		capabilityHandlers: {
+			page_to_markdown: true,
+		},
+	})),
+}))
+
+vi.mock('#mcp/run-codemode-registry.ts', () => ({
+	runCodemodeWithRegistry: (...args: Array<unknown>) =>
+		mockModule.runCodemodeWithRegistry(...args),
+}))
+
+vi.mock('#mcp/capabilities/registry.ts', () => ({
+	getCapabilityRegistryForContext: (...args: Array<unknown>) =>
+		mockModule.getCapabilityRegistryForContext(...args),
+}))
+
+const { registerExecuteTool } = await import('./execute.ts')
+
+beforeEach(() => {
+	vi.clearAllMocks()
+})
+
+async function getExecuteHandler() {
 	const registerTool = vi.fn()
 
 	await registerExecuteTool({
 		server: {
 			registerTool,
 		} as never,
-		getEnv: vi.fn(),
-		getCallerContext: vi.fn(),
+		getEnv: vi.fn(() => ({})),
+		getCallerContext: vi.fn(() => ({
+			baseUrl: 'https://example.com',
+			user: null,
+		})),
 		requireDomain: vi.fn(),
 		getLoopbackExports: vi.fn(),
 	} as never)
@@ -18,4 +46,90 @@ test('registers execute tool', async () => {
 	const [name, , handler] = registerTool.mock.calls[0] ?? []
 	expect(name).toBe('execute')
 	expect(typeof handler).toBe('function')
+	return handler as (input: {
+		code: string
+		conversationId?: string
+	}) => Promise<{
+		content: Array<ContentBlock>
+		structuredContent: {
+			conversationId: string
+			result: unknown
+			logs: Array<unknown>
+		}
+		isError: boolean
+	}>
+}
+
+test('registers execute tool', async () => {
+	await getExecuteHandler()
+})
+
+test('execute tool passes through raw MCP content blocks in success responses', async () => {
+	const handler = await getExecuteHandler()
+	const rawContent: Array<ContentBlock> = [
+		{
+			type: 'image',
+			data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB',
+			mimeType: 'image/png',
+		},
+		{
+			type: 'text',
+			text: 'Screenshot of https://example.com',
+		},
+	]
+	mockModule.runCodemodeWithRegistry.mockResolvedValueOnce({
+		result: {
+			__mcpContent: rawContent,
+		},
+		logs: [{ level: 'info', message: 'captured screenshot' }],
+	})
+
+	const response = await handler({
+		code: 'async () => ({ __mcpContent: [] })',
+		conversationId: 'conv-123',
+	})
+
+	expect(response.isError).toBe(false)
+	expect(response.content).toEqual([
+		{
+			type: 'text',
+			text: 'conversationId: conv-123',
+		},
+		...rawContent,
+	])
+	expect(response.structuredContent).toEqual({
+		conversationId: 'conv-123',
+		result: null,
+		logs: [{ level: 'info', message: 'captured screenshot' }],
+	})
+})
+
+test('execute tool keeps serializing normal success results as text', async () => {
+	const handler = await getExecuteHandler()
+	mockModule.runCodemodeWithRegistry.mockResolvedValueOnce({
+		result: { ok: true },
+		logs: [],
+	})
+
+	const response = await handler({
+		code: 'async () => ({ ok: true })',
+		conversationId: 'conv-456',
+	})
+
+	expect(response.isError).toBe(false)
+	expect(response.content).toEqual([
+		{
+			type: 'text',
+			text: 'conversationId: conv-456',
+		},
+		{
+			type: 'text',
+			text: '{\n  "ok": true\n}',
+		},
+	])
+	expect(response.structuredContent).toEqual({
+		conversationId: 'conv-456',
+		result: { ok: true },
+		logs: [],
+	})
 })

packages/worker/src/mcp/tools/execute.ts

@@ -2,6 +2,7 @@ import * as Sentry from '@sentry/cloudflare'
 import { type ToolAnnotations } from '@modelcontextprotocol/sdk/types.js'
 import { z } from 'zod'
 import {
+	extractRawContent,
 	formatExecutionOutput,
 	getExecutionErrorDetails,
 } from '#mcp/executor.ts'
@@ -189,17 +190,20 @@ export async function registerExecuteTool(agent: McpRegistrationAgent) {
 				registeredCapabilityCount,
 				sandboxError: false,
 			})
+			const rawContent = extractRawContent(result.result)
 			return {
 				content: prependToolMetadataContent(resolvedConversationId, [
-					{
-						type: 'text',
-						text: formatExecutionOutput(result),
-					},
+					...(rawContent ?? [
+						{
+							type: 'text',
+							text: formatExecutionOutput(result),
+						},
+					]),
 					...formatSurfacedMemoriesMarkdown(surfacedMemories),
 				]),
 				structuredContent: {
 					conversationId: resolvedConversationId,
-					result: result.result,
+					result: rawContent ? null : result.result,
 					logs: result.logs ?? [],
 					...buildMemoryStructuredContent(surfacedMemories),
 				},