@cloudflare/codemode 0.0.8 → 0.1.1

package/e2e/worker.ts

@@ -0,0 +1,144 @@
+import { Agent, routeAgentRequest, getAgentByName } from "agents";
+import {
+  streamText,
+  convertToModelMessages,
+  stepCountIs,
+  tool,
+  type UIMessage
+} from "ai";
+import { createWorkersAI } from "workers-ai-provider";
+import { z } from "zod";
+import { createCodeTool } from "../src/ai";
+import { DynamicWorkerExecutor, generateTypes } from "../src/index";
+
+type Env = {
+  AI: Ai;
+  LOADER: WorkerLoader;
+  CodemodeAgent: DurableObjectNamespace<CodemodeAgent>;
+};
+
+const pmTools = {
+  createProject: tool({
+    description: "Create a new project",
+    inputSchema: z.object({
+      name: z.string().describe("Project name"),
+      description: z.string().optional().describe("Project description")
+    }),
+    execute: async ({ name, description }) => ({
+      id: crypto.randomUUID(),
+      name,
+      description: description ?? ""
+    })
+  }),
+
+  listProjects: tool({
+    description: "List all projects",
+    inputSchema: z.object({}),
+    execute: async () => [
+      { id: "proj-1", name: "Alpha", description: "First project" },
+      { id: "proj-2", name: "Beta", description: "Second project" }
+    ]
+  }),
+
+  addNumbers: tool({
+    description: "Add two numbers together",
+    inputSchema: z.object({
+      a: z.number().describe("First number"),
+      b: z.number().describe("Second number")
+    }),
+    execute: async ({ a, b }) => ({ result: a + b })
+  }),
+
+  getWeather: tool({
+    description: "Get the current weather for a city",
+    inputSchema: z.object({
+      city: z.string().describe("The city name")
+    }),
+    execute: async ({ city }) => ({
+      city,
+      temperature: 22,
+      condition: "Sunny"
+    })
+  })
+};
+
+export class CodemodeAgent extends Agent<Env> {
+  observability = undefined;
+
+  async onRequest(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname.endsWith("/chat") && request.method === "POST") {
+      return this.handleChat(request);
+    }
+
+    if (url.pathname.endsWith("/generate-types")) {
+      return Response.json({ types: generateTypes(pmTools) });
+    }
+
+    return new Response("Not found", { status: 404 });
+  }
+
+  async handleChat(request: Request): Promise<Response> {
+    const body = (await request.json()) as { messages: UIMessage[] };
+
+    const workersai = createWorkersAI({ binding: this.env.AI });
+    const model = workersai("@cf/zai-org/glm-4.7-flash");
+
+    const executor = new DynamicWorkerExecutor({
+      loader: this.env.LOADER
+    });
+
+    const codemode = createCodeTool({
+      tools: pmTools,
+      executor
+    });
+
+    const result = streamText({
+      model,
+      system: `You are a helpful assistant with access to a codemode tool.
+When asked to perform operations, use the codemode tool to write JavaScript code that calls the available functions on the \`codemode\` object.
+Keep responses very short (1-2 sentences max).
+When asked to add numbers, use the addNumbers tool via codemode.
+When asked about weather, use the getWeather tool via codemode.
+When asked about projects, use createProject or listProjects via codemode.`,
+      messages: await convertToModelMessages(body.messages),
+      tools: { codemode },
+      stopWhen: stepCountIs(5)
+    });
+
+    return result.toTextStreamResponse();
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env, _ctx: ExecutionContext) {
+    const url = new URL(request.url);
+
+    if (url.pathname.startsWith("/agents/")) {
+      return (
+        (await routeAgentRequest(request, env)) ||
+        new Response("Not found", { status: 404 })
+      );
+    }
+
+    if (url.pathname === "/run" && request.method === "POST") {
+      const agent = await getAgentByName(env.CodemodeAgent, "e2e-test");
+      const agentUrl = new URL(request.url);
+      agentUrl.pathname = "/chat";
+      return agent.fetch(
+        new Request(agentUrl.toString(), {
+          method: "POST",
+          headers: request.headers,
+          body: request.body
+        })
+      );
+    }
+
+    if (url.pathname === "/types") {
+      return Response.json({ types: generateTypes(pmTools) });
+    }
+
+    return new Response("OK");
+  }
+};

package/e2e/wrangler.jsonc

@@ -0,0 +1,14 @@
+{
+  "ai": { "binding": "AI", "remote": true },
+  "compatibility_date": "2026-01-28",
+  "compatibility_flags": ["nodejs_compat"],
+  "define": {
+    "__filename": "'index.ts'"
+  },
+  "durable_objects": {
+    "bindings": [{ "class_name": "CodemodeAgent", "name": "CodemodeAgent" }]
+  },
+  "main": "worker.ts",
+  "migrations": [{ "new_sqlite_classes": ["CodemodeAgent"], "tag": "v1" }],
+  "worker_loaders": [{ "binding": "LOADER" }]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/codemode",
-  "version": "0.0.8",
+  "version": "0.1.1",
   "description": "Code Mode: use LLMs to generate executable code that performs tool calls",
   "repository": {
     "directory": "packages/codemode",
@@ -11,18 +11,26 @@
     "url": "https://github.com/cloudflare/agents/issues"
   },
   "dependencies": {
+    "acorn": "^8.16.0",
     "zod-to-ts": "^2.0.0"
   },
   "devDependencies": {
-    "ai": "^6.0.86",
+    "@playwright/test": "^1.58.2",
+    "ai": "^6.0.97",
+    "vitest": "3.2.4",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "agents": "^0.5.0",
     "ai": "^6.0.0",
     "zod": "^3.25.0 || ^4.0.0"
   },
+  "types": "dist/index.d.ts",
   "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
     "./ai": {
       "types": "./dist/ai.d.ts",
       "import": "./dist/ai.js",
@@ -30,7 +38,10 @@
     }
   },
   "scripts": {
-    "build": "tsx ./scripts/build.ts"
+    "build": "tsx ./scripts/build.ts",
+    "test": "vitest run",
+    "test:e2e": "npx playwright test --config e2e/playwright.config.ts",
+    "test:watch": "vitest"
   },
   "keywords": [
     "cloudflare",

package/scripts/build.ts

@@ -5,7 +5,7 @@ async function main() {
   await build({
     clean: true,
     dts: true,
-    entry: ["src/ai.ts"],
+    entry: ["src/index.ts", "src/ai.ts"],
     skipNodeModulesBundle: true,
     external: ["cloudflare:workers"],
     format: "esm",
@@ -20,7 +20,6 @@ async function main() {
 }
 
 main().catch((err) => {
-  // Build failures should fail
   console.error(err);
   process.exit(1);
 });

package/src/ai.ts

@@ -1,247 +1 @@
-import { generateObject, tool, type ToolSet, type LanguageModel } from "ai";
-import { z } from "zod";
-import { compile as compileJsonSchemaToTs } from "json-schema-to-typescript";
-import {
-  zodToTs,
-  printNode as printNodeZodToTs,
-  createTypeAlias
-} from "zod-to-ts";
-import { getAgentByName } from "agents";
-import { env, WorkerEntrypoint } from "cloudflare:workers";
-import { openai } from "@ai-sdk/openai";
-
-function toCamelCase(str: string) {
-  return str
-    .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
-    .replace(/^[a-z]/, (letter) => letter.toUpperCase());
-}
-
-export class CodeModeProxy extends WorkerEntrypoint<
-  Cloudflare.Env,
-  {
-    binding: string;
-    name: string;
-    callback: string;
-  }
-> {
-  async callFunction(options: { functionName: string; args: unknown[] }) {
-    const stub = (await getAgentByName(
-      // @ts-expect-error
-      env[this.ctx.props.binding] as DurableObjectNamespace<T>,
-      this.ctx.props.name
-    )) as DurableObjectStub;
-    // @ts-expect-error
-    return stub[this.ctx.props.callback](options.functionName, options.args);
-  }
-}
-
-export async function experimental_codemode(options: {
-  tools: ToolSet;
-  prompt: string;
-  globalOutbound: Fetcher;
-  loader: WorkerLoader;
-  proxy: Fetcher<CodeModeProxy>;
-  model?: LanguageModel;
-}): Promise<{
-  prompt: string;
-  tools: ToolSet;
-}> {
-  const generatedTypes = await generateTypes(options.tools);
-  const prompt = `${options.prompt}
-  You are a helpful assistant. You have access to the "codemode" tool that can do different things: 
-  
-  ${getToolDescriptions(options.tools)} 
-  
-  If the user asks to do anything that be achieveable by the codemode tool, then simply pass over control to it by giving it a simple function description. Don't be too verbose.
-  
-  `;
-
-  const codemodeTool = tool({
-    description: "codemode: a tool that can generate code to achieve a goal",
-    inputSchema: z.object({
-      functionDescription: z.string()
-    }),
-    outputSchema: z.object({
-      code: z.string(),
-      result: z.any()
-    }),
-    execute: async ({ functionDescription }) => {
-      try {
-        const response = await generateObject({
-          model: options.model ? options.model : openai("gpt-4.1"),
-          schema: z.object({
-            code: z.string()
-          }),
-          prompt: `You are a code generating machine.
-
-      In addition to regular javascript, you can also use the following functions:
-
-      ${generatedTypes}      
-
-      Respond only with the code, nothing else. Output javascript code.
-
-      Generate an async function that achieves the goal. This async function doesn't accept any arguments.
-
-      Here is user input: ${functionDescription}` // insert ts types for the tools here
-        });
-
-        // console.log("args", response.object.args);
-        const evaluator = createEvaluator(response.object.code, {
-          proxy: options.proxy,
-          loader: options.loader
-        });
-        const result = await evaluator();
-        return { code: response.object.code, result: result };
-      } catch (error) {
-        console.error("error", error);
-        throw error;
-        // return { code: "", result: error };
-      }
-    }
-  });
-
-  return { prompt, tools: { codemode: codemodeTool } };
-}
-
-function createEvaluator(
-  code: string,
-  options: {
-    loader: WorkerLoader;
-    proxy: Fetcher<CodeModeProxy>;
-  }
-) {
-  return async () => {
-    const worker = options.loader.get(`code-${Math.random()}`, () => {
-      return {
-        compatibilityDate: "2025-06-01",
-        compatibilityFlags: ["nodejs_compat"],
-        mainModule: "foo.js",
-        modules: {
-          "foo.js": `
-import { env, WorkerEntrypoint } from "cloudflare:workers";
-
-export default class CodeModeWorker extends WorkerEntrypoint {
-  async evaluate() {
-    try {
-      const { CodeModeProxy } = env;
-      const codemode = new Proxy(
-        {},
-        {
-          get: (target, prop) => {
-            return (args) => {
-              return CodeModeProxy.callFunction({
-                functionName: prop,
-                args: args,                
-              });
-            };
-          }
-        }
-      );
-
-      return await ${code}();
-    } catch (err) {
-      return {
-        err: err.message,
-        stack: err.stack
-      };
-    }
-  }
-}
-            
-        `
-        },
-        env: {
-          // insert keys and bindings to tools/ts functions here
-          CodeModeProxy: options.proxy
-        },
-        globalOutbound: null
-      };
-    });
-
-    // @ts-expect-error TODO: fix this
-    return await worker.getEntrypoint().evaluate();
-  };
-}
-
-async function generateTypes(tools: ToolSet) {
-  let availableTools = "";
-  let availableTypes = "";
-
-  for (const [toolName, tool] of Object.entries(tools)) {
-    // @ts-expect-error TODO: fix this
-    const inputJsonType = tool.inputSchema.jsonSchema
-      ? await compileJsonSchemaToTs(
-          // @ts-expect-error TODO: fix this
-          tool.inputSchema.jsonSchema,
-          `${toCamelCase(toolName)}Input`,
-          {
-            format: false,
-            bannerComment: " "
-          }
-        )
-      : printNodeZodToTs(
-          createTypeAlias(
-            zodToTs(
-              // @ts-expect-error TODO: fix this
-              tool.inputSchema,
-              `${toCamelCase(toolName)}Input`
-            ).node,
-            `${toCamelCase(toolName)}Input`
-          )
-        );
-
-    const outputJsonType =
-      // @ts-expect-error TODO: fix this
-      tool.outputSchema?.jsonSchema
-        ? await compileJsonSchemaToTs(
-            // @ts-expect-error TODO: fix this
-            tool.outputSchema?.jsonSchema,
-            `${toCamelCase(toolName)}Output`,
-            {
-              format: false,
-              bannerComment: " "
-            }
-          )
-        : tool.outputSchema
-          ? printNodeZodToTs(
-              createTypeAlias(
-                zodToTs(
-                  // @ts-expect-error TODO: fix this
-                  tool.outputSchema,
-                  `${toCamelCase(toolName)}Output`
-                ).node,
-                `${toCamelCase(toolName)}Output`
-              )
-            )
-          : `interface ${toCamelCase(toolName)}Output { [key: string]: any }`;
-
-    const InputType = inputJsonType
-      .trim()
-      .replace("export interface", "interface");
-
-    const OutputType = outputJsonType
-      .trim()
-      .replace("export interface", "interface");
-
-    availableTypes += `\n${InputType}`;
-    availableTypes += `\n${OutputType}`;
-    availableTools += `\n\t/*\n\t${tool.description?.trim()}\n\t*/`;
-    availableTools += `\n\t${toolName}: (input: ${toCamelCase(toolName)}Input) => Promise<${toCamelCase(toolName)}Output>;`;
-    availableTools += "\n";
-  }
-
-  availableTools = `\ndeclare const codemode: {${availableTools}}`;
-
-  return `
-${availableTypes}
-${availableTools}
-      `;
-}
-
-function getToolDescriptions(tools: ToolSet) {
-  return Object.entries(tools)
-    .map(([_toolName, tool]) => {
-      return `\n- ${tool.description?.trim()}`;
-    })
-    .join("");
-}
+export { createCodeTool, type CreateCodeToolOptions } from "./tool";

package/src/executor.ts

@@ -0,0 +1,170 @@
+/**
+ * Executor interface and DynamicWorkerExecutor implementation.
+ *
+ * The Executor interface is the core abstraction — implement it to run
+ * LLM-generated code in any sandbox (Workers, QuickJS, Node VM, etc.).
+ */
+
+import { RpcTarget } from "cloudflare:workers";
+
+export interface ExecuteResult {
+  result: unknown;
+  error?: string;
+  logs?: string[];
+}
+
+/**
+ * An executor runs LLM-generated code in a sandbox, making the provided
+ * tool functions callable as `codemode.*` inside the sandbox.
+ *
+ * Implementations should never throw — errors are returned in `ExecuteResult.error`.
+ */
+export interface Executor {
+  execute(
+    code: string,
+    fns: Record<string, (...args: unknown[]) => Promise<unknown>>
+  ): Promise<ExecuteResult>;
+}
+
+// -- ToolDispatcher (RPC target for tool calls from sandboxed Workers) --
+
+/**
+ * An RpcTarget that dispatches tool calls from the sandboxed Worker
+ * back to the host. Passed via Workers RPC to the dynamic Worker's
+ * evaluate() method — no globalOutbound or Fetcher bindings needed.
+ */
+export class ToolDispatcher extends RpcTarget {
+  #fns: Record<string, (...args: unknown[]) => Promise<unknown>>;
+
+  constructor(fns: Record<string, (...args: unknown[]) => Promise<unknown>>) {
+    super();
+    this.#fns = fns;
+  }
+
+  async call(name: string, argsJson: string): Promise<string> {
+    const fn = this.#fns[name];
+    if (!fn) {
+      return JSON.stringify({ error: `Tool "${name}" not found` });
+    }
+    try {
+      const args = argsJson ? JSON.parse(argsJson) : {};
+      const result = await fn(args);
+      return JSON.stringify({ result });
+    } catch (err) {
+      return JSON.stringify({
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+
+// -- DynamicWorkerExecutor (Cloudflare Workers) --
+
+export interface DynamicWorkerExecutorOptions {
+  loader: WorkerLoader;
+  /**
+   * Timeout in milliseconds for code execution. Defaults to 30000 (30s).
+   */
+  timeout?: number;
+  /**
+   * Controls outbound network access from sandboxed code.
+   * - `null` (default): fetch() and connect() throw — sandbox is fully isolated.
+   * - `undefined`: inherits parent Worker's network access (full internet).
+   * - A `Fetcher`: all outbound requests route through this handler.
+   */
+  globalOutbound?: Fetcher | null;
+}
+
+/**
+ * Executes code in an isolated Cloudflare Worker via WorkerLoader.
+ * Tool calls are dispatched via Workers RPC — the host passes a
+ * ToolDispatcher (RpcTarget) to the Worker's evaluate() method.
+ *
+ * External fetch() and connect() are blocked by default via
+ * `globalOutbound: null` (runtime-enforced). Pass a Fetcher to
+ * `globalOutbound` to allow controlled outbound access.
+ */
+export class DynamicWorkerExecutor implements Executor {
+  #loader: WorkerLoader;
+  #timeout: number;
+  #globalOutbound: Fetcher | null;
+
+  constructor(options: DynamicWorkerExecutorOptions) {
+    this.#loader = options.loader;
+    this.#timeout = options.timeout ?? 30000;
+    this.#globalOutbound = options.globalOutbound ?? null;
+  }
+
+  async execute(
+    code: string,
+    fns: Record<string, (...args: unknown[]) => Promise<unknown>>
+  ): Promise<ExecuteResult> {
+    const timeoutMs = this.#timeout;
+
+    const modulePrefix = [
+      'import { WorkerEntrypoint } from "cloudflare:workers";',
+      "",
+      "export default class CodeExecutor extends WorkerEntrypoint {",
+      "  async evaluate(dispatcher) {",
+      "    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(" ")); };',
+      "    const codemode = new Proxy({}, {",
+      "      get: (_, toolName) => async (args) => {",
+      "        const resJson = await dispatcher.call(String(toolName), JSON.stringify(args ?? {}));",
+      "        const data = JSON.parse(resJson);",
+      "        if (data.error) throw new Error(data.error);",
+      "        return data.result;",
+      "      }",
+      "    });",
+      "",
+      "    try {",
+      "      const result = await Promise.race([",
+      "        ("
+    ].join("\n");
+
+    const moduleSuffix = [
+      ")(),",
+      '        new Promise((_, reject) => setTimeout(() => reject(new Error("Execution timed out")), ' +
+        timeoutMs +
+        "))",
+      "      ]);",
+      "      return { result, logs: __logs };",
+      "    } catch (err) {",
+      "      return { result: undefined, error: err.message, logs: __logs };",
+      "    }",
+      "  }",
+      "}"
+    ].join("\n");
+
+    const executorModule = modulePrefix + code + moduleSuffix;
+
+    const dispatcher = new ToolDispatcher(fns);
+
+    const worker = this.#loader.get(`codemode-${crypto.randomUUID()}`, () => ({
+      compatibilityDate: "2025-06-01",
+      compatibilityFlags: ["nodejs_compat"],
+      mainModule: "executor.js",
+      modules: {
+        "executor.js": executorModule
+      },
+      globalOutbound: this.#globalOutbound
+    }));
+
+    const entrypoint = worker.getEntrypoint() as unknown as {
+      evaluate(dispatcher: ToolDispatcher): Promise<{
+        result: unknown;
+        error?: string;
+        logs?: string[];
+      }>;
+    };
+    const response = await entrypoint.evaluate(dispatcher);
+
+    if (response.error) {
+      return { result: undefined, error: response.error, logs: response.logs };
+    }
+
+    return { result: response.result, logs: response.logs };
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export {
+  DynamicWorkerExecutor,
+  ToolDispatcher,
+  type DynamicWorkerExecutorOptions,
+  type Executor,
+  type ExecuteResult
+} from "./executor";
+export {
+  generateTypes,
+  sanitizeToolName,
+  type ToolDescriptor,
+  type ToolDescriptors
+} from "./types";

package/src/tests/cloudflare-test.d.ts

@@ -0,0 +1,5 @@
+declare module "cloudflare:test" {
+  interface ProvidedEnv {
+    LOADER: WorkerLoader;
+  }
+}