构建 AI 代码解释器

const timeoutMs = 5_000;

export async function runJavaScript(env, code) {
	const sandbox = env.LOADER.load({
		compatibilityDate: "2026-11-14",
		mainModule: "code.js",
		modules: {
			"code.js": `
                import { WorkerEntrypoint } from "cloudflare:workers";

                function format(value) {
                    return typeof value === "string" ? value : JSON.stringify(value);
                }

                export class Code extends WorkerEntrypoint {
                    async run() {
                        const logs = [];
                        const console = {
                            log: (...values) => logs.push(values.map(format).join(" ")),
                        };
                        const result = await (async () => {
                            ${code}
                        })();
                        return { result, logs };
                    }
                }
            `,
		},
		globalOutbound: null,
		limits: { cpuMs: 50 },
	});

	let timer = null;
	const timeout = new Promise((_, reject) => {
		timer = setTimeout(() => {
			reject(new Error(`The code did not finish within ${timeoutMs} ms`));
		}, timeoutMs);
	});

	try {
		return await Promise.race([sandbox.getEntrypoint("Code").run(), timeout]);
	} finally {
		clearTimeout(timer);
	}
}

import type { WorkerEntrypoint } from "cloudflare:workers";

export type Output = {
    result?: unknown;
    logs: string[];
};

type CodeEntrypoint = WorkerEntrypoint & {
    run(): Promise<Output>;
};

const timeoutMs = 5_000;

export async function runJavaScript(env: Env, code: string): Promise<Output> {
    const sandbox = env.LOADER.load({
        compatibilityDate: "2026-11-14",
        mainModule: "code.js",
        modules: {
            "code.js": `
                import { WorkerEntrypoint } from "cloudflare:workers";

                function format(value) {
                    return typeof value === "string" ? value : JSON.stringify(value);
                }

                export class Code extends WorkerEntrypoint {
                    async run() {
                        const logs = [];
                        const console = {
                            log: (...values) => logs.push(values.map(format).join(" ")),
                        };
                        const result = await (async () => {
                            ${code}
                        })();
                        return { result, logs };
                    }
                }
            `,
        },
        globalOutbound: null,
        limits: { cpuMs: 50 },
    });

    let timer: number | null = null;
    const timeout = new Promise<never>((_, reject) => {
        timer = setTimeout(() => {
            reject(new Error(`The code did not finish within ${timeoutMs} ms`));
        }, timeoutMs);
    });

    try {
        return await Promise.race([
            sandbox.getEntrypoint<CodeEntrypoint>("Code").run(),
            timeout,
        ]);
    } finally {
        clearTimeout(timer);
    }
}

import { generateText, isStepCount, tool } from "ai";
import { createAI } from "agents/models/ai-sdk";
import { z } from "zod";
import { runJavaScript } from "./sandbox";

const model = "@cf/openai/gpt-oss-120b";

const Question = z.object({ question: z.string().min(1) });

const instructions = `Answer the question.
Always call the runJavaScript tool before you answer. Do not calculate, count, or sort in your head.
Write the body of an async JavaScript function and return the value you need.
If the tool returns an error, fix the code and run it again.
Answer in one or two plain-text sentences.`;

export default {
	async fetch(request, env) {
		if (request.method !== "POST") {
			return new Response("Send a POST request", { status: 405 });
		}

		const body = Question.safeParse(await request.json().catch(() => null));

		if (!body.success) {
			return Response.json(
				{ error: "Send a JSON body with a question" },
				{ status: 400 },
			);
		}

		const ai = createAI({ binding: env.AI });
		const runs = [];

		try {
			const result = await generateText({
				model: ai(model),
				instructions,
				prompt: body.data.question,
				tools: {
					runJavaScript: tool({
						description:
							"Run JavaScript in a sandbox with no network access. The code is the body of an async function. Return a JSON-serializable value. console.log output is captured.",
						inputSchema: z.object({
							code: z.string().describe("Body of an async JavaScript function"),
						}),
						execute: async ({ code }) => {
							try {
								const output = await runJavaScript(env, code);
								runs.push({ code, output });
								return output;
							} catch (error) {
								const message =
									error instanceof Error ? error.message : String(error);
								runs.push({ code, error: message });
								return { error: message };
							}
						},
					}),
				},
				// Stop after five model steps, so a model that keeps failing cannot
				// run code indefinitely
				stopWhen: isStepCount(5),
			});

			return Response.json({ answer: result.text, runs });
		} catch (error) {
			console.error("Model request failed", error);
			return Response.json(
				{ error: "The model request failed. Try again later.", runs },
				{ status: 502 },
			);
		}
	},
};

import { generateText, isStepCount, tool } from "ai";
import { createAI } from "agents/models/ai-sdk";
import { z } from "zod";
import { runJavaScript, type Output } from "./sandbox";

const model = "@cf/openai/gpt-oss-120b";

const Question = z.object({ question: z.string().min(1) });

const instructions = `Answer the question.
Always call the runJavaScript tool before you answer. Do not calculate, count, or sort in your head.
Write the body of an async JavaScript function and return the value you need.
If the tool returns an error, fix the code and run it again.
Answer in one or two plain-text sentences.`;

type Run = { code: string } & ({ output: Output } | { error: string });

export default {
    async fetch(request: Request, env: Env): Promise<Response> {
        if (request.method !== "POST") {
            return new Response("Send a POST request", { status: 405 });
        }

        const body = Question.safeParse(await request.json().catch(() => null));

        if (!body.success) {
            return Response.json(
                { error: "Send a JSON body with a question" },
                { status: 400 },
            );
        }

        const ai = createAI({ binding: env.AI });
        const runs: Run[] = [];

        try {
            const result = await generateText({
                model: ai(model),
                instructions,
                prompt: body.data.question,
                tools: {
                    runJavaScript: tool({
                        description:
                            "Run JavaScript in a sandbox with no network access. The code is the body of an async function. Return a JSON-serializable value. console.log output is captured.",
                        inputSchema: z.object({
                            code: z.string().describe("Body of an async JavaScript function"),
                        }),
                        execute: async ({ code }) => {
                            try {
                                const output = await runJavaScript(env, code);
                                runs.push({ code, output });
                                return output;
                            } catch (error) {
                                const message =
                                    error instanceof Error ? error.message : String(error);
                                runs.push({ code, error: message });
                                return { error: message };
                            }
                        },
                    }),
                },
                // Stop after five model steps, so a model that keeps failing cannot
                // run code indefinitely
                stopWhen: isStepCount(5),
            });

            return Response.json({ answer: result.text, runs });
        } catch (error) {
            console.error("Model request failed", error);
            return Response.json(
                { error: "The model request failed. Try again later.", runs },
                { status: 502 },
            );
        }
    },
} satisfies ExportedHandler<Env>;