diff --git a/packages/worker/client/mcp-apps/generated-ui-runtime-contract.ts b/packages/worker/client/mcp-apps/generated-ui-runtime-contract.ts
index d080b075aa..3aeeede39b 100644
--- a/packages/worker/client/mcp-apps/generated-ui-runtime-contract.ts
+++ b/packages/worker/client/mcp-apps/generated-ui-runtime-contract.ts
@@ -43,7 +43,7 @@ export type GeneratedUiRuntimeBootstrap = {
 	appSession?: GeneratedUiAppSessionBootstrap | null
 }
 
-export const generatedUiRuntimeModuleSpecifier = '@kody/utils' as const
+export const generatedUiRuntimeModuleSpecifier = '@kody/ui-utils' as const
 
 export function buildGeneratedUiRuntimeImportMap(runtimeScriptHref: string) {
 	const importMapJson = escapeInlineScriptSource(
diff --git a/packages/worker/client/mcp-apps/generated-ui-widget-runtime.ts b/packages/worker/client/mcp-apps/generated-ui-widget-runtime.ts
index ab14c84186..61df974c16 100644
--- a/packages/worker/client/mcp-apps/generated-ui-widget-runtime.ts
+++ b/packages/worker/client/mcp-apps/generated-ui-widget-runtime.ts
@@ -193,7 +193,7 @@ export function getKodyWidget(): KodyWidgetPublicApi {
 		return widget
 	}
 	throw new Error(
-		'kodyWidget is not ready yet. Import `whenKodyWidgetReady()` from `@kody/utils` and await it before using the runtime helpers.',
+		'kodyWidget is not ready yet. Import `whenKodyWidgetReady()` from `@kody/ui-utils` and await it before using the runtime helpers.',
 	)
 }
 
diff --git a/packages/worker/src/app/saved-ui-hosted-html.node.test.ts b/packages/worker/src/app/saved-ui-hosted-html.node.test.ts
index 090cf62293..58d36272f3 100644
--- a/packages/worker/src/app/saved-ui-hosted-html.node.test.ts
+++ b/packages/worker/src/app/saved-ui-hosted-html.node.test.ts
@@ -39,7 +39,7 @@ test('renderHostedSavedUiHtml emits shared runtime assets for html apps', () =>
 		'<script type="module" src="https://kody.example/mcp-apps/generated-ui-runtime.js"></script>',
 	)
 	expect(result).toContain(
-		'<script type="importmap">{"imports":{"@kody/utils":"https://kody.example/mcp-apps/generated-ui-runtime.js"}}</script>',
+		'<script type="importmap">{"imports":{"@kody/ui-utils":"https://kody.example/mcp-apps/generated-ui-runtime.js"}}</script>',
 	)
 	expect(result).toContain(
 		'window.__kodyGeneratedUiBootstrap = {"mode":"hosted","appSession":{"token":"token-123","endpoints":{"source":"https://kody.example/ui-api/session-123/source","execute":"https://kody.example/ui-api/session-123/execute","secrets":"https://kody.example/ui-api/session-123/secrets","deleteSecret":"https://kody.example/ui-api/session-123/secrets/delete"}}};',
@@ -69,7 +69,7 @@ test('renderHostedSavedUiHtml keeps user javascript separate from runtime bootst
 		'<script type="module" src="https://kody.example/mcp-apps/generated-ui-runtime.js"></script>',
 	)
 	expect(result).toContain(
-		'<script type="importmap">{"imports":{"@kody/utils":"https://kody.example/mcp-apps/generated-ui-runtime.js"}}</script>',
+		'<script type="importmap">{"imports":{"@kody/ui-utils":"https://kody.example/mcp-apps/generated-ui-runtime.js"}}</script>',
 	)
 	expect(result).toContain(
 		'<script type="module">\ndocument.querySelector("[data-generated-ui-root]")?.append("hello")',
diff --git a/packages/worker/src/mcp/capabilities/apps/ui-save-app.ts b/packages/worker/src/mcp/capabilities/apps/ui-save-app.ts
index 3c48ed1320..ff60a22d54 100644
--- a/packages/worker/src/mcp/capabilities/apps/ui-save-app.ts
+++ b/packages/worker/src/mcp/capabilities/apps/ui-save-app.ts
@@ -43,7 +43,7 @@ const inputSchema = z.object({
 		.array(uiArtifactParameterSchema)
 		.optional()
 		.describe(
-			'Optional parameter definitions for reusable saved apps. Resolved values are exposed at runtime on the imported `kodyWidget.params` helper from `@kody/utils`.',
+			'Optional parameter definitions for reusable saved apps. Resolved values are exposed at runtime on the imported `kodyWidget.params` helper from `@kody/ui-utils`.',
 		),
 })
 
diff --git a/packages/worker/src/mcp/capabilities/apps/ui-update-app.ts b/packages/worker/src/mcp/capabilities/apps/ui-update-app.ts
index 753c1393ff..f7d6bb4feb 100644
--- a/packages/worker/src/mcp/capabilities/apps/ui-update-app.ts
+++ b/packages/worker/src/mcp/capabilities/apps/ui-update-app.ts
@@ -60,7 +60,7 @@ const inputSchema = z
 			.array(uiArtifactParameterSchema)
 			.optional()
 			.describe(
-				'Optional parameter definitions for reusable saved apps. Resolved values are exposed at runtime on the imported `kodyWidget.params` API from `@kody/utils`.',
+				'Optional parameter definitions for reusable saved apps. Resolved values are exposed at runtime on the imported `kodyWidget.params` API from `@kody/ui-utils`.',
 			),
 	})
 	.refine(
diff --git a/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.node.test.ts b/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.node.test.ts
index 02fe294ac3..af01cb7267 100644
--- a/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.node.test.ts
+++ b/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.node.test.ts
@@ -25,5 +25,7 @@ test('generated_ui_oauth_guide distinguishes PKCE and server-side exchange helpe
 	)
 	expect(result.body).toContain('`exchangeOAuthCodeWithSecrets(...)`')
 	expect(result.body).toContain('run server-side')
+	expect(result.body).toContain("import { kodyWidget } from '@kody/ui-utils'")
+	expect(result.body).not.toContain('@kody/utils')
 	expect(result.body).not.toContain('exchangeOAuthCode({ tokenUrl')
 })
diff --git a/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.ts b/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.ts
index 11e4db4b92..50e8e009ea 100644
--- a/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.ts
+++ b/packages/worker/src/mcp/capabilities/coding/generated-ui-oauth-guide.ts
@@ -71,7 +71,7 @@ of treating it like a secret.
 4. Give the user the hosted saved-app URL and tell them to open it in their
    browser instead of trying to complete the flow in the conversation iframe.
 5. In the hosted generated UI, import \`kodyWidget\` from
-   \`@kody/utils\` and use it directly to read the callback, validate state,
+   \`@kody/ui-utils\` and use it directly to read the callback, validate state,
    exchange the code in the browser, and save tokens.
 
 ## Generated UI helpers to use
@@ -105,7 +105,7 @@ before building the authorization URL or token request.
 \`\`\`html
 <p id="status"></p>
 <script type="module">
-  import { kodyWidget } from '@kody/utils'
+  import { kodyWidget } from '@kody/ui-utils'
 
   async function requireClientId() {
     const clientIdRecord = await kodyWidget.getValue({
@@ -188,7 +188,7 @@ authorization flow.
   <button type="submit">Save and continue</button>
 </form>
 <script type="module">
-  import { kodyWidget } from '@kody/utils'
+  import { kodyWidget } from '@kody/ui-utils'
 
   document.querySelector('#oauth-client-form')?.addEventListener('submit', async (event) => {
     event.preventDefault()
@@ -240,7 +240,7 @@ Create and persist the OAuth state before redirecting the browser.
 \`\`\`html
 <button id="connect-muffin-club">Connect Muffin Club</button>
 <script type="module">
-  import { kodyWidget } from '@kody/utils'
+  import { kodyWidget } from '@kody/ui-utils'
 
   document.querySelector('#connect-muffin-club')?.addEventListener('click', async () => {
     const clientIdRecord = await kodyWidget.getValue({
@@ -340,7 +340,7 @@ succeeds.
     root.innerHTML = '<p>' + message + '</p>'
   }
 
-  import { kodyWidget } from '@kody/utils'
+  import { kodyWidget } from '@kody/ui-utils'
 
   void (async () => {
     const callback = kodyWidget.readOAuthCallback({
@@ -427,7 +427,7 @@ export const generatedUiOAuthGuideCapability = defineDomainCapability(
 			'provider registration',
 			'ui_save_app',
 			'open_generated_ui',
-			'@kody/utils',
+			'@kody/ui-utils',
 		],
 		readOnly: true,
 		idempotent: true,
diff --git a/packages/worker/src/mcp/executor.node.test.ts b/packages/worker/src/mcp/executor.node.test.ts
index c5b74def77..bc09d06504 100644
--- a/packages/worker/src/mcp/executor.node.test.ts
+++ b/packages/worker/src/mcp/executor.node.test.ts
@@ -5,7 +5,230 @@ import {
 	createHostSecretAccessDeniedBatchMessage,
 	createMissingSecretMessage,
 } from '#mcp/secrets/errors.ts'
-import { formatExecutionOutput, getExecutionErrorDetails } from './executor.ts'
+import {
+	createExecuteExecutor,
+	formatExecutionOutput,
+	getExecutionErrorDetails,
+} from './executor.ts'
+
+function createTestLoader(): WorkerLoader {
+	return {
+		get(_name, getCode) {
+			return {
+				getEntrypoint() {
+					return {
+						async evaluate(dispatchers: Record<string, { call: (name: string, argsJson: string) => Promise<string> }>) {
+							const workerCode = await getCode()
+							const modules = Object.fromEntries(
+								Object.entries(workerCode.modules).map(([key, value]) => [
+									key,
+									typeof value === 'string' ? value : (value.js ?? ''),
+								]),
+							)
+							const source = modules['executor.js']
+							if (!source) {
+								throw new Error('Missing executor.js module.')
+							}
+							const moduleCache = new Map<string, Promise<unknown>>()
+							const loadModule = async (specifier: string): Promise<unknown> => {
+								const cached = moduleCache.get(specifier)
+								if (cached) return cached
+								const moduleSource = modules[specifier]
+								if (!moduleSource) {
+									throw new Error(`Unknown module: ${specifier}`)
+								}
+								const modulePromise = (async () => {
+									const exports: Record<string, unknown> = Object.create(null)
+									const exportNames = Array.from(
+										moduleSource.matchAll(
+											/export\s+(?:async\s+function|function|const|class)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+										),
+									).map((match) => match[1]!)
+									const transformed = moduleSource
+										.replace(
+											/import\s+\{\s*([^}]+)\s*\}\s+from\s+["']([^"']+)["'];?/g,
+											(_match, names, importSpecifier) =>
+												`const { ${names.trim()} } = await __importModule(${JSON.stringify(importSpecifier)});`,
+										)
+										.replace(
+											/import\s+\*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+["']([^"']+)["'];?/g,
+											(_match, name, importSpecifier) =>
+												`const ${name} = await __importModule(${JSON.stringify(importSpecifier)});`,
+										)
+										.replace(
+											/export default class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+											'class $1',
+										)
+										.replace(
+											/export default async \(\)\s*=>/g,
+											'exports.default = async () =>',
+										)
+										.replace(
+											/export default /g,
+											'exports.default = ',
+										)
+										.replace(
+											/export async function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+											'exports.$1 = async function $1',
+										)
+										.replace(
+											/export function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+											'exports.$1 = function $1',
+										)
+										.replace(
+											/export const\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+											'exports.$1 =',
+										)
+									const evaluator = new Function(
+										'exports',
+										'__importModule',
+										`return (async () => { ${transformed}\n${exportNames
+											.map((name) => `exports.${name} = ${name};`)
+											.join('\n')} })();`,
+									)
+									await evaluator(exports, loadModule)
+									return exports
+								})()
+								moduleCache.set(specifier, modulePromise)
+								return await modulePromise
+							}
+							const cloudflareWorkersExports = {
+								WorkerEntrypoint: class {
+									constructor(
+										readonly ctx: { props?: unknown } = {},
+										readonly env: unknown = {},
+									) {}
+								},
+							}
+							const mainModule = source.replace(
+								/import\s+\{\s*WorkerEntrypoint\s*\}\s+from\s+"cloudflare:workers";?/g,
+								'const { WorkerEntrypoint } = __cloudflareWorkers;',
+							)
+							const transformed = mainModule
+								.replace(
+									/export default class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+									'class $1',
+								)
+								.replace(
+									/import\s+\{\s*([^}]+)\s*\}\s+from\s+"([^"]+)";?/g,
+									(_match, names, importSpecifier) =>
+										`const { ${names.trim()} } = await __importModule(${JSON.stringify(importSpecifier)});`,
+								)
+							const exportsObject: Record<string, unknown> = Object.create(null)
+							const evaluator = new Function(
+								'exports',
+								'__dispatchers',
+								'__importModule',
+								'__cloudflareWorkers',
+								`return (async () => { ${transformed}
+if (typeof CodeExecutor !== 'undefined') exports.default = CodeExecutor;
+return exports.default; })();`,
+							)
+							const EntrypointClass = (await evaluator(
+								exportsObject,
+								dispatchers,
+								loadModule,
+								cloudflareWorkersExports,
+							)) as {
+								new (
+									ctx: { props?: unknown },
+									env: unknown,
+								): { evaluate(dispatchers: Record<string, unknown>): Promise<unknown> }
+							}
+							const instance = new EntrypointClass({}, {})
+							return instance.evaluate(dispatchers)
+						},
+					}
+				},
+			}
+		},
+	}
+}
+
+test('createExecuteExecutor returns results for async arrow execute code', async () => {
+	const executor = createExecuteExecutor({
+		env: {
+			LOADER: createTestLoader(),
+		} as Env,
+		exports: {
+			CodemodeFetchGateway() {
+				return {} as Fetcher
+			},
+		} as typeof import('cloudflare:workers').exports,
+		gatewayProps: {
+			baseUrl: 'https://kody.example',
+			userId: 'user-123',
+			storageContext: null,
+		},
+	})
+
+	const result = await executor.execute(
+		`async () =>
+			await codemode.ui_save_app({
+				title: 'Execute generated app',
+				description: 'Saved through execute.',
+				keywords: ['execute', 'ui'],
+				code: '<main><h1>Execute App</h1></main>',
+			})`,
+		[
+			{
+				name: 'codemode',
+				fns: {
+					async ui_save_app() {
+						return {
+							app_id: 'app-123',
+							hosted_url: 'https://kody.example/ui/app-123',
+						}
+					},
+				},
+			},
+		],
+	)
+
+	expect(result).toEqual({
+		result: {
+			app_id: 'app-123',
+			hosted_url: 'https://kody.example/ui/app-123',
+		},
+		logs: [],
+	})
+})
+
+test('createExecuteExecutor rejects top-level import in execute code', async () => {
+	const executor = createExecuteExecutor({
+		env: {
+			LOADER: createTestLoader(),
+		} as Env,
+		exports: {
+			CodemodeFetchGateway() {
+				return {} as Fetcher
+			},
+		} as typeof import('cloudflare:workers').exports,
+		gatewayProps: {
+			baseUrl: 'https://kody.example',
+			userId: 'user-123',
+			storageContext: null,
+		},
+	})
+
+	const result = await executor.execute(
+		`// import should not trigger module mode by itself
+async () => ({ ok: true })`,
+		[
+			{
+				name: 'codemode',
+				fns: {},
+			},
+		],
+	)
+
+	expect(result).toEqual({
+		result: {
+			ok: true,
+		},
+		logs: [],
+	})
+})
 
 test('getExecutionErrorDetails returns concrete guidance for capability access denial', () => {
 	const error = new Error(
diff --git a/packages/worker/src/mcp/executor.ts b/packages/worker/src/mcp/executor.ts
index 565a6d88c3..33f00c51a0 100644
--- a/packages/worker/src/mcp/executor.ts
+++ b/packages/worker/src/mcp/executor.ts
@@ -1,6 +1,13 @@
-import { DynamicWorkerExecutor, type ExecuteResult } from '@cloudflare/codemode'
+import {
+	DynamicWorkerExecutor,
+	type ExecuteResult,
+	type ResolvedProvider,
+	ToolDispatcher,
+	normalizeCode,
+	sanitizeToolName,
+} from '@cloudflare/codemode'
+import * as acorn from 'acorn'
 import { exports as workerExports } from 'cloudflare:workers'
-type WorkerLoopbackExports = Exclude<typeof workerExports, undefined>
 import { type FetchGatewayProps } from '#mcp/fetch-gateway.ts'
 import {
 	isSecretAuthRequiredMessage,
@@ -10,6 +17,12 @@ import {
 	parseHostApprovalRequiredMessage,
 	parseMissingSecretMessage,
 } from '#mcp/secrets/errors.ts'
+import {
+	buildCodemodeUtilsModuleSource,
+	codemodeUtilsModuleSpecifier,
+} from '#mcp/tools/codemode-utils.ts'
+
+type WorkerLoopbackExports = Exclude<typeof workerExports, undefined>
 
 const charsPerToken = 4
 const maxTokens = 6_000
@@ -26,13 +39,220 @@ export function createExecuteExecutor(input: {
 			'CodemodeFetchGateway export is required for execute-time fetch.',
 		)
 	}
-	return new DynamicWorkerExecutor({
-		loader: input.env.LOADER,
-		timeout: 90_000,
-		globalOutbound: loopbackExports.CodemodeFetchGateway({
-			props: input.gatewayProps,
-		}),
+	const globalOutbound = loopbackExports.CodemodeFetchGateway({
+		props: input.gatewayProps,
 	})
+	return {
+		execute(code: string, providersOrFns: Array<ResolvedProvider>) {
+			if (codeNeedsModuleRunner(code)) {
+				return Promise.resolve({
+					result: undefined,
+					error:
+						'Top-level import or export is not supported in the execute sandbox. Use an async arrow function body and dynamic import() instead (for example: const m = await import("@kody/codemode-utils")).',
+					logs: [],
+				})
+			}
+			const workerLoaderModules: Record<string, WorkerLoaderModule | string> = {}
+			const dynamicExecutorModules: Record<string, string> = {}
+			if (codeReferencesCodemodeUtils(code)) {
+				workerLoaderModules[codemodeUtilsModuleSpecifier] = {
+					js: buildCodemodeUtilsModuleSource(),
+				}
+				dynamicExecutorModules[codemodeUtilsModuleSpecifier] =
+					buildCodemodeUtilsModuleSource()
+			}
+			const mergedWorkerLoaderModules =
+				Object.keys(workerLoaderModules).length > 0
+					? workerLoaderModules
+					: undefined
+			const mergedDynamicExecutorModules =
+				Object.keys(dynamicExecutorModules).length > 0
+					? dynamicExecutorModules
+					: undefined
+			if (codeReferencesCodemodeUtils(code)) {
+				return executeDynamicWithKodyUtilsBridge({
+					loader: input.env.LOADER,
+					timeoutMs: 90_000,
+					globalOutbound,
+					modules: mergedWorkerLoaderModules,
+					code,
+					providers: providersOrFns,
+				})
+			}
+			const executor = new DynamicWorkerExecutor({
+				loader: input.env.LOADER,
+				timeout: 90_000,
+				globalOutbound,
+				modules: mergedDynamicExecutorModules,
+			})
+			return executor.execute(code, providersOrFns)
+		},
+	}
+}
+
+function validateExecuteProviders(
+	providers: Array<ResolvedProvider>,
+): ExecuteResult | null {
+	const reservedNames = new Set(['__dispatchers', '__logs'])
+	const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
+	const seenNames = new Set<string>()
+	for (const provider of providers) {
+		if (reservedNames.has(provider.name)) {
+			return {
+				result: undefined,
+				error: `Provider name "${provider.name}" is reserved`,
+			}
+		}
+		if (!validIdentifier.test(provider.name)) {
+			return {
+				result: undefined,
+				error: `Provider name "${provider.name}" is not a valid JavaScript identifier`,
+			}
+		}
+		if (seenNames.has(provider.name)) {
+			return {
+				result: undefined,
+				error: `Duplicate provider name "${provider.name}"`,
+			}
+		}
+		seenNames.add(provider.name)
+	}
+	return null
+}
+
+function buildKodyUtilsProviderSetupLines(
+	providers: Array<ResolvedProvider>,
+): Array<string> {
+	const lines: Array<string> = ['    const __kodyProviders = {};']
+	for (const p of providers) {
+		if (p.positionalArgs) {
+			lines.push(`    const ${p.name} = new Proxy({}, {
+      get: (_, toolName) => async (...args) => {
+        const resJson = await __dispatchers.${p.name}.call(String(toolName), JSON.stringify(args));
+        const data = JSON.parse(resJson);
+        if (data.error) throw new Error(data.error);
+        return data.result;
+      }
+    });`)
+		} else {
+			lines.push(`    const ${p.name} = new Proxy({}, {
+      get: (_, toolName) => async (args) => {
+        const resJson = await __dispatchers.${p.name}.call(String(toolName), JSON.stringify(args ?? {}));
+        const data = JSON.parse(resJson);
+        if (data.error) throw new Error(data.error);
+        return data.result;
+      }
+    });`)
+		}
+		lines.push(`    __kodyProviders.${p.name} = ${p.name};`)
+	}
+	lines.push('    globalThis.__kodyProviders = __kodyProviders;')
+	return lines
+}
+
+async function executeDynamicWithKodyUtilsBridge(input: {
+	loader: WorkerLoader
+	timeoutMs: number
+	globalOutbound: Fetcher
+	modules?: Record<string, WorkerLoaderModule | string>
+	code: string
+	providers: Array<ResolvedProvider>
+}): Promise<ExecuteResult> {
+	const validationError = validateExecuteProviders(input.providers)
+	if (validationError) return validationError
+
+	const normalized = normalizeCode(input.code)
+	const timeoutMs = input.timeoutMs
+	const executorModule = [
+		'import { WorkerEntrypoint } from "cloudflare:workers";',
+		'',
+		'export default class CodeExecutor extends WorkerEntrypoint {',
+		'  async evaluate(__dispatchers = {}) {',
+		'    const __logs = [];',
+		'    console.log = (...a) => { __logs.push(a.map(String).join(" ")); };',
+		'    console.warn = (...a) => { __logs.push("[warn] " + a.map(String).join(" ")); };',
+		'    console.error = (...a) => { __logs.push("[error] " + a.map(String).join(" ")); };',
+		...buildKodyUtilsProviderSetupLines(input.providers),
+		'    try {',
+		'      const result = await Promise.race([',
+		'        (',
+		normalized,
+		')(),',
+		`        new Promise((_, reject) => setTimeout(() => reject(new Error("Execution timed out")), ${timeoutMs}))`,
+		'      ]);',
+		'      return { result, logs: __logs };',
+		'    } catch (err) {',
+		'      return { result: undefined, error: err instanceof Error ? err.message : String(err), logs: __logs };',
+		'    } finally {',
+		'      delete globalThis.__kodyProviders;',
+		'    }',
+		'  }',
+		'}',
+	].join('\n')
+
+	const dispatchers = Object.create(null) as Record<string, ToolDispatcher>
+	for (const provider of input.providers) {
+		const sanitizedFns = Object.fromEntries(
+			Object.entries(provider.fns).map(([name, fn]) => [sanitizeToolName(name), fn]),
+		)
+		dispatchers[provider.name] = new ToolDispatcher(
+			sanitizedFns,
+			provider.positionalArgs,
+		)
+	}
+
+	type CodeExecutorEntrypoint = {
+		evaluate(dispatchers: Record<string, ToolDispatcher>): Promise<ExecuteResult>
+	}
+
+	const entrypoint = input.loader
+		.get(`codemode-${crypto.randomUUID()}`, () => ({
+			compatibilityDate: '2025-06-01',
+			compatibilityFlags: ['nodejs_compat'],
+			mainModule: 'executor.js',
+			modules: {
+				...(input.modules ?? {}),
+				'executor.js': executorModule,
+			},
+			globalOutbound: input.globalOutbound,
+		}))
+		.getEntrypoint() as unknown as CodeExecutorEntrypoint
+
+	const response = await entrypoint.evaluate(dispatchers)
+	if (response.error) {
+		return {
+			result: undefined,
+			error: response.error,
+			logs: response.logs,
+		}
+	}
+	return {
+		result: response.result,
+		logs: response.logs ?? [],
+	}
+}
+
+function codeReferencesCodemodeUtils(code: string) {
+	return code.includes(codemodeUtilsModuleSpecifier)
+}
+
+function codeNeedsModuleRunner(code: string) {
+	const trimmed = code.trim()
+	try {
+		const parsed = acorn.parse(trimmed, {
+			ecmaVersion: 'latest',
+			sourceType: 'module',
+		})
+		return parsed.body.some(
+			(node: acorn.Node) =>
+				node.type === 'ImportDeclaration' ||
+				node.type === 'ExportDefaultDeclaration' ||
+				node.type === 'ExportNamedDeclaration' ||
+				node.type === 'ExportAllDeclaration',
+		)
+	} catch {
+		return false
+	}
 }
 
 export type ExecutionErrorDetails =
diff --git a/packages/worker/src/mcp/generated-ui-api.ts b/packages/worker/src/mcp/generated-ui-api.ts
index 17509c05c8..d28eb74896 100644
--- a/packages/worker/src/mcp/generated-ui-api.ts
+++ b/packages/worker/src/mcp/generated-ui-api.ts
@@ -248,7 +248,7 @@ function createGeneratedUiExecuteHandler(env: Env) {
 					{
 						ok: false,
 						error:
-							'Generated UI executeCode may not return unresolved `{{secret:...}}` placeholders. Secret placeholders only resolve inside secret-aware fetch requests or capability inputs that explicitly opt into `x-kody-secret`. Use persisted values for non-secret configuration, and call `kodyWidget.sendMessage(...)` (for example after `import { kodyWidget } from "@kody/utils"`) when the user needs to intervene.',
+							'Generated UI executeCode may not return unresolved `{{secret:...}}` placeholders. Secret placeholders only resolve inside secret-aware fetch requests or capability inputs that explicitly opt into `x-kody-secret`. Use persisted values for non-secret configuration, and call `kodyWidget.sendMessage(...)` (for example after `import { kodyWidget } from "@kody/ui-utils"`) when the user needs to intervene.',
 						logs: result.logs ?? [],
 					},
 					400,
diff --git a/packages/worker/src/mcp/generated-ui-app-base-url.node.test.ts b/packages/worker/src/mcp/generated-ui-app-base-url.node.test.ts
index 95258dd346..3ff607556a 100644
--- a/packages/worker/src/mcp/generated-ui-app-base-url.node.test.ts
+++ b/packages/worker/src/mcp/generated-ui-app-base-url.node.test.ts
@@ -21,7 +21,7 @@ test('canonical APP_BASE_URL drives runtime script href and MCP URL for widget d
 	const html = renderGeneratedUiRuntimeHtmlEntry(appBase)
 	expect(html).toContain('https://heykody.dev/mcp-apps/generated-ui-runtime.js')
 	expect(html).toContain(
-		'"@kody/utils":"https://heykody.dev/mcp-apps/generated-ui-runtime.js"',
+		'"@kody/ui-utils":"https://heykody.dev/mcp-apps/generated-ui-runtime.js"',
 	)
 
 	const mcpServerUrl = new URL(mcpResourcePath, appBase).toString()
diff --git a/packages/worker/src/mcp/index.ts b/packages/worker/src/mcp/index.ts
index 739670b0ba..6e9a01f84f 100644
--- a/packages/worker/src/mcp/index.ts
+++ b/packages/worker/src/mcp/index.ts
@@ -87,7 +87,7 @@ How to use execute
 - Secret placeholders are not general-purpose string interpolation. Do not use \`execute\` to build a string or object that merely returns \`{{secret:...}}\`; those placeholders only resolve in secret-aware fetch paths or capability inputs that explicitly opt into \`x-kody-secret\`.
 - Saving or updating a secret does not authorize sending it anywhere. If a fetch fails because a host is not approved for that secret, ask the user whether to open the approval link and approve that host in the web app.
 - Secrets are intentionally not readable or updatable through \`codemode\`. Never ask the user to paste a secret into chat; use generated UI flows such as \`saveSecret(...)\` when the user needs to provide or rotate a value, and use \`codemode.secret_delete(...)\` only when removing a stored secret reference.
-- Your code must be an async arrow function that returns the result.
+- Your code should either be an async arrow function that returns the result, or a module that default-exports an async function when using imports.
 - Example: const result = await codemode[capabilityName](args)
 
 MCP App tools
@@ -95,7 +95,7 @@ MCP App tools
 - Pass either inline source code with 'code' or reopen a saved app with 'app_id' (exactly one is allowed).
 - Prefer body-focused HTML fragments when possible, but full HTML documents are also supported.
 - Use generated UI whenever the user needs to enter a sensitive value. Do not ask the user to paste secrets or credentials into chat.
-- Generated UI code can import \`{ kodyWidget }\` from \`@kody/utils\` and use helpers for follow-up messages, external links, fullscreen requests, \`executeCode(code)\`, secret management, values, forms, OAuth, and secret-aware fetches.
+- Generated UI code can import \`{ kodyWidget }\` from \`@kody/ui-utils\` and use helpers for follow-up messages, external links, fullscreen requests, \`executeCode(code)\`, secret management, values, forms, OAuth, and secret-aware fetches.
 - 'executeCode(code)' is the low-level transport for server-side generated UI work. Prefer the higher-level secret and value helpers when they fit the task.
 - If a generated UI encounters a recoverable runtime issue, have it show the problem locally and also call 'sendMessage(...)' with the next action the user should take so the parent chat can continue the workflow.
 - The shell also provides lightweight semantic HTML styles plus theme tokens such as '--color-*', '--spacing-*', '--radius-*', '--shadow-*', and '--font-*'.
diff --git a/packages/worker/src/mcp/mcp-server.mcp-e2e.test.ts b/packages/worker/src/mcp/mcp-server.mcp-e2e.test.ts
index 8f650e360a..e578082873 100644
--- a/packages/worker/src/mcp/mcp-server.mcp-e2e.test.ts
+++ b/packages/worker/src/mcp/mcp-server.mcp-e2e.test.ts
@@ -864,7 +864,7 @@ test('mcp server opens generated ui with inline code and serves runtime resource
 	expect(generatedResource?.text).toContain('"mode":"entry"')
 	expect(generatedResource?.text).not.toContain('Toggle fullscreen')
 	expect(generatedResource?.text).not.toContain('Open saved app link')
-	expect(generatedResource?.text).toContain('"@kody/utils"')
+	expect(generatedResource?.text).toContain('"@kody/ui-utils"')
 	expect(generatedResource?.text).toContain('type="module"')
 	expect(generatedResource?.text).toContain('/mcp-apps/generated-ui-runtime.js')
 
diff --git a/packages/worker/src/mcp/tools/codemode-utils.ts b/packages/worker/src/mcp/tools/codemode-utils.ts
new file mode 100644
index 0000000000..b1f2bfd6d9
--- /dev/null
+++ b/packages/worker/src/mcp/tools/codemode-utils.ts
@@ -0,0 +1,267 @@
+export const codemodeUtilsModuleSpecifier = '@kody/codemode-utils' as const
+
+export function buildCodemodeUtilsModuleSource() {
+	return `
+function isRecord(value) {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function requireCodemode() {
+	const providers = globalThis.__kodyProviders
+	const codemode = providers && typeof providers === 'object' ? providers.codemode : globalThis.codemode
+	if (!codemode || typeof codemode !== 'object') {
+		throw new Error('@kody/codemode-utils requires the codemode provider.')
+	}
+	return codemode
+}
+
+function buildConnectorValueName(name) {
+	return '_connector:' + name
+}
+
+function normalizeOptionalName(value) {
+	return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null
+}
+
+function normalizeConnectorConfig(value, fallbackName) {
+	if (!isRecord(value)) return null
+	const name =
+		typeof value.name === 'string' && value.name.trim().length > 0
+			? value.name.trim()
+			: typeof fallbackName === 'string' && fallbackName.trim().length > 0
+				? fallbackName.trim()
+				: null
+	const flow = value.flow === 'pkce' || value.flow === 'confidential' ? value.flow : null
+	const tokenUrl =
+		typeof value.tokenUrl === 'string' && value.tokenUrl.trim().length > 0
+			? value.tokenUrl.trim()
+			: null
+	const clientIdValueName =
+		typeof value.clientIdValueName === 'string' &&
+		value.clientIdValueName.trim().length > 0
+			? value.clientIdValueName.trim()
+			: null
+	const accessTokenSecretName =
+		typeof value.accessTokenSecretName === 'string' &&
+		value.accessTokenSecretName.trim().length > 0
+			? value.accessTokenSecretName.trim()
+			: null
+	if (!name || !flow || !tokenUrl || !clientIdValueName || !accessTokenSecretName) {
+		return null
+	}
+	return {
+		name,
+		tokenUrl,
+		flow,
+		clientIdValueName,
+		clientSecretSecretName: normalizeOptionalName(value.clientSecretSecretName),
+		accessTokenSecretName,
+		refreshTokenSecretName: normalizeOptionalName(value.refreshTokenSecretName),
+		requiredHosts: Array.isArray(value.requiredHosts)
+			? value.requiredHosts.filter((entry) => typeof entry === 'string')
+			: [],
+	}
+}
+
+async function readConnectorConfig(providerName) {
+	if (typeof providerName !== 'string' || providerName.trim().length === 0) {
+		throw new Error('Provider name is required.')
+	}
+	const normalizedProviderName = providerName.trim()
+	const codemode = requireCodemode()
+	if (typeof codemode.connector_get === 'function') {
+		const result = await codemode.connector_get({ name: normalizedProviderName })
+		const connector = isRecord(result) ? result.connector : null
+		const parsed = normalizeConnectorConfig(connector, normalizedProviderName)
+		if (parsed) {
+			return parsed
+		}
+	}
+	if (typeof codemode.value_get !== 'function') {
+		throw new Error(
+			'@kody/codemode-utils requires codemode.value_get when connector_get is unavailable.',
+		)
+	}
+	const storedValue = await codemode.value_get({
+		name: buildConnectorValueName(normalizedProviderName),
+		scope: 'user',
+	})
+	if (!isRecord(storedValue) || typeof storedValue.value !== 'string') {
+		throw new Error('Connector "' + normalizedProviderName + '" is not configured.')
+	}
+	let parsedJson = null
+	try {
+		parsedJson = JSON.parse(storedValue.value)
+	} catch {
+		throw new Error(
+			'Connector "' + normalizedProviderName + '" has invalid JSON config.',
+		)
+	}
+	const parsed = normalizeConnectorConfig(parsedJson, normalizedProviderName)
+	if (!parsed) {
+		throw new Error(
+			'Connector "' + normalizedProviderName + '" has invalid config.',
+		)
+	}
+	return parsed
+}
+
+async function readRequiredValue(name) {
+	const codemode = requireCodemode()
+	if (typeof codemode.value_get !== 'function') {
+		throw new Error('@kody/codemode-utils requires codemode.value_get.')
+	}
+	const value = await codemode.value_get({ name })
+	if (!isRecord(value) || typeof value.value !== 'string' || value.value.length === 0) {
+		throw new Error('Value "' + name + '" is not configured.')
+	}
+	return value.value
+}
+
+function buildSecretPlaceholder(name) {
+	return '{{secret:' + name + '}}'
+}
+
+function encodeFormComponent(value) {
+	return typeof value === 'string' &&
+		value.startsWith('{{secret:') &&
+		value.endsWith('}}')
+		? value
+		: encodeURIComponent(String(value))
+}
+
+function buildFormBody(entries) {
+	return entries
+		.filter((entry) => entry[1] != null && String(entry[1]).length > 0)
+		.map(
+			([key, value]) =>
+				encodeURIComponent(String(key)) + '=' + encodeFormComponent(value),
+		)
+		.join('&')
+}
+
+async function parseTokenResponse(response) {
+	const text = await response.text()
+	let data = null
+	const contentType = response.headers.get('content-type') || ''
+	if (
+		text &&
+		(/\\bjson\\b/i.test(contentType) ||
+			text.startsWith('{') ||
+			text.startsWith('['))
+	) {
+		try {
+			data = JSON.parse(text)
+		} catch {}
+	}
+	return { text, data }
+}
+
+function getTokenRefreshErrorMessage(providerName, response, payload) {
+	if (isRecord(payload.data)) {
+		if (
+			typeof payload.data.error_description === 'string' &&
+			payload.data.error_description.length > 0
+		) {
+			return payload.data.error_description
+		}
+		if (
+			typeof payload.data.error === 'string' &&
+			payload.data.error.length > 0
+		) {
+			return payload.data.error
+		}
+	}
+	return (
+		payload.text ||
+		'Token refresh for "' +
+			providerName +
+			'" failed with HTTP status ' +
+			response.status +
+			'.'
+	)
+}
+
+function assertRequestHostAllowed(connector, requestUrl) {
+	if (!Array.isArray(connector.requiredHosts) || connector.requiredHosts.length === 0) {
+		return
+	}
+	const host = new URL(requestUrl).hostname.toLowerCase()
+	const allowedHosts = connector.requiredHosts.map((entry) =>
+		String(entry).toLowerCase(),
+	)
+	if (!allowedHosts.includes(host)) {
+		throw new Error(
+			'Authenticated fetch for "' +
+				connector.name +
+				'" is not allowed for host "' +
+				host +
+				'". Allowed hosts: ' +
+				allowedHosts.join(', ') +
+				'.',
+		)
+	}
+}
+
+export async function refreshAccessToken(providerName) {
+	const connector = await readConnectorConfig(providerName)
+	if (!connector.refreshTokenSecretName) {
+		throw new Error(
+			'Connector "' + connector.name + '" is missing refreshTokenSecretName.',
+		)
+	}
+	const clientId = await readRequiredValue(connector.clientIdValueName)
+	const body = buildFormBody([
+		['grant_type', 'refresh_token'],
+		['client_id', clientId],
+		['refresh_token', buildSecretPlaceholder(connector.refreshTokenSecretName)],
+		...(connector.flow === 'confidential' && connector.clientSecretSecretName
+			? [
+					[
+						'client_secret',
+						buildSecretPlaceholder(connector.clientSecretSecretName),
+					],
+				]
+			: []),
+	])
+	const response = await fetch(connector.tokenUrl, {
+		method: 'POST',
+		headers: {
+			Accept: 'application/json',
+			'Content-Type': 'application/x-www-form-urlencoded',
+		},
+		body,
+	})
+	const payload = await parseTokenResponse(response)
+	if (!response.ok) {
+		throw new Error(
+			getTokenRefreshErrorMessage(connector.name, response, payload),
+		)
+	}
+	const accessToken =
+		isRecord(payload.data) && typeof payload.data.access_token === 'string'
+			? payload.data.access_token
+			: null
+	if (!accessToken) {
+		throw new Error(
+			'Token refresh for "' +
+				connector.name +
+				'" did not return an access_token.',
+		)
+	}
+	return accessToken
+}
+
+export async function createAuthenticatedFetch(providerName) {
+	const connector = await readConnectorConfig(providerName)
+	const accessToken = await refreshAccessToken(providerName)
+	return async function authenticatedFetch(input, init) {
+		const request = new Request(input, init)
+		assertRequestHostAllowed(connector, request.url)
+		const headers = new Headers(request.headers)
+		headers.set('Authorization', 'Bearer ' + accessToken)
+		return fetch(new Request(request, { headers }))
+	}
+}
+`.trim()
+}
diff --git a/packages/worker/src/mcp/tools/execute.ts b/packages/worker/src/mcp/tools/execute.ts
index 213de8301f..8d9c108483 100644
--- a/packages/worker/src/mcp/tools/execute.ts
+++ b/packages/worker/src/mcp/tools/execute.ts
@@ -24,7 +24,7 @@ To run a saved skill by id, prefer \`meta_run_skill\` with \`skill_id\` and
 optional \`params\`. If you need the saved code, call \`meta_get_skill\` and
 pass the returned code into this tool.
 
-This tool accepts a single argument: \`{ "code": "async () => { ... }" }\`.
+This tool accepts a single argument: \`{ "code": "..." }\`.
 
 Available in your code:
 
@@ -62,7 +62,9 @@ Values:
 - Use \`await codemode.value_get({ name })\` or \`await codemode.value_list({ scope })\` for readable non-secret configuration that generated UI code should be able to save and read back later.
 - Do not store readable public identifiers as secrets just to make them persistent; use value capabilities or the generated UI value helpers instead.
 
-Your code must be an async arrow function that returns the result.
+Your code should be an async arrow function that returns the result. Do not use top-level
+\`import\` or \`export\`; load helpers with dynamic \`import()\` inside the function body
+(for example \`await import('@kody/codemode-utils')\`).
 
 Examples:
 
@@ -75,6 +77,12 @@ Examples:
     preview: docs.body.slice(0, 120),
   };
 }\`
+
+\`async () => {
+  const { refreshAccessToken } = await import('@kody/codemode-utils')
+  const token = await refreshAccessToken('spotify')
+  return { tokenPreview: token.slice(0, 8) }
+}\`
 	`.trim(),
 	annotations: {
 		readOnlyHint: false,
@@ -84,6 +92,14 @@ Examples:
 	} satisfies ToolAnnotations,
 } as const
 
+function toJsonSafeForMcpStructuredContent(value: unknown): unknown {
+	try {
+		return JSON.parse(JSON.stringify(value))
+	} catch {
+		return null
+	}
+}
+
 export async function registerExecuteTool(agent: McpRegistrationAgent) {
 	agent.server.registerTool(
 		executeTool.name,
@@ -93,7 +109,9 @@ export async function registerExecuteTool(agent: McpRegistrationAgent) {
 			inputSchema: {
 				code: z
 					.string()
-					.describe('JavaScript async arrow function to execute capabilities.'),
+					.describe(
+						'JavaScript execute code. Use an async arrow function, or top-level imports with normal statements/returns.',
+					),
 			},
 			annotations: executeTool.annotations,
 		},
@@ -184,7 +202,9 @@ export async function registerExecuteTool(agent: McpRegistrationAgent) {
 					},
 				],
 				structuredContent: {
-					result: result.result,
+					// WorkerLoader RPC can return plain objects that still fail MCP / workerd
+					// structured serialization; JSON round-trip yields a fully JSON-safe value.
+					result: toJsonSafeForMcpStructuredContent(result.result),
 					logs: result.logs ?? [],
 				},
 			}
diff --git a/packages/worker/src/mcp/tools/open-generated-ui.ts b/packages/worker/src/mcp/tools/open-generated-ui.ts
index c210230d45..f971cce39e 100644
--- a/packages/worker/src/mcp/tools/open-generated-ui.ts
+++ b/packages/worker/src/mcp/tools/open-generated-ui.ts
@@ -21,11 +21,11 @@ Behavior:
 - Accepts exactly one of \`code\` or \`app_id\`.
 - Use \`code\` to render a new UI artifact immediately without saving it first.
 - Use \`app_id\` to reopen previously saved UI source without sending that source code back through the model.
-- Saved apps can declare reusable parameters; pass runtime values via \`params\` and read them from \`kodyWidget.params\` after importing \`kodyWidget\` from \`@kody/utils\`.
+- Saved apps can declare reusable parameters; pass runtime values via \`params\` and read them from \`kodyWidget.params\` after importing \`kodyWidget\` from \`@kody/ui-utils\`.
 - \`code\` may be a full HTML document or a fragment.
 
 Generated UI basics:
-- The runtime exposes module helpers from the \`@kody/utils\` import-map alias; prefer \`import { kodyWidget } from '@kody/utils'\`.
+- The runtime exposes module helpers from the \`@kody/ui-utils\` import-map alias; prefer \`import { kodyWidget } from '@kody/ui-utils'\`.
 - Use generated UI whenever the user needs to enter sensitive values. Do not ask the user to paste credentials into chat.
 - If generated UI code hits a recoverable runtime problem, show it in the UI and also call \`sendMessage(...)\` with the next action.
 - For browser-based OAuth flows, call the \`generated_ui_oauth_guide\` capability first and follow that guide for callback URLs, registration values, \`getValue(...)\`, token exchange, and host approval handling.