@cloudflare/codemode 0.0.1 → 0.0.4

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# @cloudflare/codemode
+
+## 0.0.4
+
+### Patch Changes
+
+- [#771](https://github.com/cloudflare/agents/pull/771) [`87dc96d`](https://github.com/cloudflare/agents/commit/87dc96d19de1d26dbb2badecbb9955a4eb8e9e2e) Thanks [@threepointone](https://github.com/threepointone)! - update dependencies
+
+- Updated dependencies [[`cf8a1e7`](https://github.com/cloudflare/agents/commit/cf8a1e7a24ecaac62c2aefca7b0fd5bf1373e8bd), [`87dc96d`](https://github.com/cloudflare/agents/commit/87dc96d19de1d26dbb2badecbb9955a4eb8e9e2e)]:
+  - agents@0.3.4
+
+## 0.0.3
+
+### Patch Changes
+
+- [`a5d0137`](https://github.com/cloudflare/agents/commit/a5d01379b9ad2d88bc028c50f1858b4e69f106c5) Thanks [@threepointone](https://github.com/threepointone)! - trigger a new release
+
+- Updated dependencies [[`a5d0137`](https://github.com/cloudflare/agents/commit/a5d01379b9ad2d88bc028c50f1858b4e69f106c5)]:
+  - agents@0.3.3
+
+## 0.0.2
+
+### Patch Changes
+
+- [#756](https://github.com/cloudflare/agents/pull/756) [`0c4275f`](https://github.com/cloudflare/agents/commit/0c4275f8f4b71c264c32c3742d151ef705739c2f) Thanks [@threepointone](https://github.com/threepointone)! - feat: split ai-chat and codemode into separate packages
+
+  Extract @cloudflare/ai-chat and @cloudflare/codemode into their own packages
+  with comprehensive READMEs. Update agents README to remove chat-specific
+  content and point to new packages. Fix documentation imports to reflect
+  new package structure.
+
+  Maintains backward compatibility, no breaking changes.
+
+- Updated dependencies [[`0c4275f`](https://github.com/cloudflare/agents/commit/0c4275f8f4b71c264c32c3742d151ef705739c2f), [`f12553f`](https://github.com/cloudflare/agents/commit/f12553f2fa65912c68d9a7620b9a11b70b8790a2)]:
+  - agents@0.3.2

package/README.md

@@ -0,0 +1,333 @@
+### 💻 `@cloudflare/codemode` - Code Mode: The Better Way to Use MCP
+
+Instead of asking LLMs to call tools directly, Code Mode lets them write executable code that orchestrates multiple operations. **LLMs are better at writing code than calling tools** - they've seen millions of lines of real-world TypeScript but only contrived tool-calling examples.
+
+Code Mode converts your tools (especially MCP servers) into TypeScript APIs, enabling complex workflows, error handling, and multi-step operations that are natural in code but difficult with traditional tool calling.
+
+Built on Cloudflare's Worker Loader API, Code Mode executes generated code in secure, isolated sandboxes with millisecond startup times.
+
+> **⚠️ Experimental Feature**: Code Mode is currently experimental and may have breaking changes in future releases. Use with caution in production environments.
+
+---
+
+### 🌱 Installation
+
+```sh
+npm install @cloudflare/codemode agents ai
+```
+
+### 📝 Your First Code Mode Agent
+
+Transform your tool-calling agent into a code-generating one:
+
+#### Before (Traditional Tool Calling)
+
+```ts
+import { streamText } from "ai";
+import { tool } from "ai";
+import { z } from "zod";
+
+const result = streamText({
+  model: openai("gpt-4o"),
+  messages,
+  tools: {
+    getWeather: tool({
+      description: "Get weather for a location",
+      inputSchema: z.object({ location: z.string() }),
+      execute: async ({ location }) => {
+        return `Weather in ${location}: 72°F, sunny`;
+      }
+    }),
+    sendEmail: tool({
+      description: "Send an email",
+      inputSchema: z.object({
+        to: z.string(),
+        subject: z.string(),
+        body: z.string()
+      }),
+      execute: async ({ to, subject, body }) => {
+        // Send email logic
+        return `Email sent to ${to}`;
+      }
+    })
+  }
+});
+```
+
+#### After (With Code Mode)
+
+```ts
+import { experimental_codemode as codemode } from "@cloudflare/codemode/ai";
+import { streamText } from "ai";
+import { tool } from "ai";
+import { z } from "zod";
+
+// Define your tools as usual
+const tools = {
+  getWeather: tool({
+    description: "Get weather for a location",
+    inputSchema: z.object({ location: z.string() }),
+    execute: async ({ location }) => {
+      return `Weather in ${location}: 72°F, sunny`;
+    }
+  }),
+  sendEmail: tool({
+    description: "Send an email",
+    inputSchema: z.object({
+      to: z.string(),
+      subject: z.string(),
+      body: z.string()
+    }),
+    execute: async ({ to, subject, body }) => {
+      // Send email logic
+      return `Email sent to ${to}`;
+    }
+  })
+};
+
+// Configure Code Mode
+const { prompt, tools: wrappedTools } = await codemode({
+  prompt: "You are a helpful assistant...",
+  tools,
+  globalOutbound: env.globalOutbound,
+  loader: env.LOADER,
+  proxy: this.ctx.exports.CodeModeProxy({
+    props: {
+      binding: "MyAgent",
+      name: this.name,
+      callback: "callTool"
+    }
+  })
+});
+
+// Use the wrapped tools - now the LLM will generate code instead!
+const result = streamText({
+  model: openai("gpt-4o"),
+  system: prompt,
+  messages,
+  tools: wrappedTools // Single "codemode" tool that generates code
+});
+```
+
+That's it! Your agent now generates executable code that orchestrates your tools.
+
+### 🏰 Configuration
+
+Define the required bindings in your `wrangler.toml`:
+
+```jsonc
+{
+  "compatibility_flags": ["experimental", "enable_ctx_exports"],
+  "worker_loaders": [
+    {
+      "binding": "LOADER"
+    }
+  ],
+  "services": [
+    {
+      "binding": "globalOutbound",
+      "service": "your-service",
+      "entrypoint": "globalOutbound"
+    },
+    {
+      "binding": "CodeModeProxy",
+      "service": "your-service",
+      "entrypoint": "CodeModeProxy"
+    }
+  ]
+}
+```
+
+### 🎭 Agent Integration
+
+#### With MCP Servers
+
+```ts
+import { Agent } from "agents";
+import { experimental_codemode as codemode } from "@cloudflare/codemode/ai";
+import { streamText, convertToModelMessages } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+export class CodeModeAgent extends Agent<Env> {
+  async onChatMessage() {
+    const allTools = {
+      ...regularTools,
+      ...this.mcp.getAITools() // Include MCP tools
+    };
+
+    const { prompt, tools: wrappedTools } = await codemode({
+      prompt: "You are a helpful assistant...",
+      tools: allTools,
+      globalOutbound: env.globalOutbound,
+      loader: env.LOADER,
+      proxy: this.ctx.exports.CodeModeProxy({
+        props: {
+          binding: "CodeModeAgent",
+          name: this.name,
+          callback: "callTool"
+        }
+      })
+    });
+
+    const result = streamText({
+      model: openai("gpt-4o"),
+      system: prompt,
+      messages: await convertToModelMessages(this.messages),
+      tools: wrappedTools
+    });
+
+    return result.toUIMessageStreamResponse();
+  }
+
+  callTool(functionName: string, args: unknown[]) {
+    return this.tools[functionName]?.execute?.(args, {
+      abortSignal: new AbortController().signal,
+      toolCallId: "codemode",
+      messages: []
+    });
+  }
+}
+
+export { CodeModeProxy } from "@cloudflare/codemode/ai";
+```
+
+### 🌊 Generated Code Example
+
+Code Mode enables complex workflows that chain multiple operations:
+
+```javascript
+// Example generated code orchestrating multiple MCP servers:
+async function executeTask() {
+  const files = await codemode.listFiles({ path: "/projects" });
+  const recentProject = files
+    .filter((f) => f.type === "directory")
+    .sort((a, b) => new Date(b.modified) - new Date(a.modified))[0];
+
+  const projectStatus = await codemode.queryDatabase({
+    query: "SELECT * FROM projects WHERE name = ?",
+    params: [recentProject.name]
+  });
+
+  if (projectStatus.length === 0 || projectStatus[0].status === "incomplete") {
+    await codemode.createTask({
+      title: `Review project: ${recentProject.name}`,
+      priority: "high"
+    });
+    await codemode.sendEmail({
+      to: "team@company.com",
+      subject: "Project Review Needed"
+    });
+  }
+
+  return { success: true, project: recentProject };
+}
+```
+
+### 🔒 Security
+
+Code runs in isolated Workers with millisecond startup times. No network access by default - only through explicit bindings. API keys are hidden in bindings, preventing leaks.
+
+```ts
+export const globalOutbound = {
+  fetch: async (input: string | URL | RequestInfo, init?: RequestInit) => {
+    const url = new URL(typeof input === "string" ? input : input.toString());
+    if (url.hostname === "example.com") {
+      return new Response("Not allowed", { status: 403 });
+    }
+    return fetch(input, init);
+  }
+};
+```
+
+### 🔧 Setup
+
+**Required bindings:**
+
+- `LOADER`: Worker Loader for code execution
+- `globalOutbound`: Service for network access control
+- `CodeModeProxy`: Service for tool execution proxy
+
+**Environment:**
+
+```ts
+export const globalOutbound = {
+  fetch: async (input: string | URL | RequestInfo, init?: RequestInit) => {
+    // Your security policies
+    return fetch(input, init);
+  }
+};
+
+export { CodeModeProxy } from "@cloudflare/codemode/ai";
+```
+
+**Proxy configuration:**
+
+```ts
+proxy: this.ctx.exports.CodeModeProxy({
+  props: {
+    binding: "YourAgentClass",
+    name: this.name,
+    callback: "callTool"
+  }
+});
+```
+
+### 🎯 Real-World Examples
+
+Explore these examples to see Code Mode in action:
+
+- **Complete Demo**: [`examples/codemode/`](../../examples/codemode/) - Full working example with MCP integration
+- **Documentation**: [`docs/codemode.md`](../../docs/codemode.md) - Detailed guide and examples
+- **Blog Post**: [Code Mode: the better way to use MCP](https://blog.cloudflare.com/code-mode/) - Deep dive into the philosophy and implementation
+
+### 📚 API Reference
+
+#### `experimental_codemode(options)`
+
+Wraps your tools with Code Mode, converting them into a single code-generating tool.
+
+**Options:**
+
+- `tools: ToolSet` - Your tool definitions (including MCP tools)
+- `prompt: string` - System prompt for the LLM
+- `globalOutbound: Fetcher` - Service binding for network access control
+- `loader: WorkerLoader` - Worker Loader binding for code execution
+- `proxy: Fetcher<CodeModeProxy>` - Proxy binding for tool execution
+
+**Returns:**
+
+- `prompt: string` - Enhanced system prompt
+- `tools: ToolSet` - Wrapped tools (single "codemode" tool)
+
+#### `CodeModeProxy`
+
+Worker entrypoint that routes tool calls back to your agent.
+
+**Props:**
+
+- `binding: string` - Your agent class name
+- `name: string` - Agent instance name
+- `callback: string` - Method name to call for tool execution
+
+### 🔗 Integration
+
+`@cloudflare/codemode` integrates with the [`agents`](../agents/) framework and works with any agent that extends `Agent`, including MCP server integration via `Agent.mcp`.
+
+### 🚀 Limitations
+
+- **Experimental**: Subject to breaking changes
+- **Requires Cloudflare Workers**: Uses Worker Loader API (beta)
+- **JavaScript Only**: Python support planned
+
+### Contributing
+
+Contributions are welcome! Please:
+
+1. Open an issue to discuss your proposal
+2. Ensure your changes align with the package's goals
+3. Include tests for new features
+4. Update documentation as needed
+
+### License
+
+MIT licensed. See the LICENSE file at the root of this repository for details.

package/dist/ai.d.ts

@@ -0,0 +1,30 @@
+import { ToolSet } from "ai";
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+//#region src/ai.d.ts
+declare class CodeModeProxy extends WorkerEntrypoint<
+  Cloudflare.Env,
+  {
+    binding: string;
+    name: string;
+    callback: string;
+  }
+> {
+  callFunction(options: {
+    functionName: string;
+    args: unknown[];
+  }): Promise<any>;
+}
+declare function experimental_codemode(options: {
+  tools: ToolSet;
+  prompt: string;
+  globalOutbound: Fetcher;
+  loader: WorkerLoader;
+  proxy: Fetcher<CodeModeProxy>;
+}): Promise<{
+  prompt: string;
+  tools: ToolSet;
+}>;
+//#endregion
+export { CodeModeProxy, experimental_codemode };
+//# sourceMappingURL=ai.d.ts.map

package/dist/ai.js

@@ -0,0 +1,147 @@
+import { generateObject, tool } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { z } from "zod";
+import { compile } from "json-schema-to-typescript";
+import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+import { getAgentByName } from "agents";
+import { WorkerEntrypoint, env } from "cloudflare:workers";
+
+//#region src/ai.ts
+function toCamelCase(str) {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/^[a-z]/, (letter) => letter.toUpperCase());
+}
+var CodeModeProxy = class extends WorkerEntrypoint {
+	async callFunction(options) {
+		return (await getAgentByName(env[this.ctx.props.binding], this.ctx.props.name))[this.ctx.props.callback](options.functionName, options.args);
+	}
+};
+async function experimental_codemode(options) {
+	const generatedTypes = await generateTypes(options.tools);
+	return {
+		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.
+  
+  `,
+		tools: { codemode: 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: 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}`
+					});
+					const result = await createEvaluator(response.object.code, {
+						proxy: options.proxy,
+						loader: options.loader
+					})();
+					return {
+						code: response.object.code,
+						result
+					};
+				} catch (error) {
+					console.error("error", error);
+					throw error;
+				}
+			}
+		}) }
+	};
+}
+function createEvaluator(code, options) {
+	return async () => {
+		return await 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: { CodeModeProxy: options.proxy },
+				globalOutbound: null
+			};
+		}).getEntrypoint().evaluate();
+	};
+}
+async function generateTypes(tools) {
+	let availableTools = "";
+	let availableTypes = "";
+	for (const [toolName, tool$1] of Object.entries(tools)) {
+		const inputJsonType = tool$1.inputSchema.jsonSchema ? await compile(tool$1.inputSchema.jsonSchema, `${toCamelCase(toolName)}Input`, {
+			format: false,
+			bannerComment: " "
+		}) : printNode(createTypeAlias(zodToTs(tool$1.inputSchema, `${toCamelCase(toolName)}Input`).node, `${toCamelCase(toolName)}Input`));
+		const outputJsonType = tool$1.outputSchema?.jsonSchema ? await compile(tool$1.outputSchema?.jsonSchema, `${toCamelCase(toolName)}Output`, {
+			format: false,
+			bannerComment: " "
+		}) : tool$1.outputSchema ? printNode(createTypeAlias(zodToTs(tool$1.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$1.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) {
+	return Object.entries(tools).map(([_toolName, tool$1]) => {
+		return `\n- ${tool$1.description?.trim()}`;
+	}).join("");
+}
+
+//#endregion
+export { CodeModeProxy, experimental_codemode };
+//# sourceMappingURL=ai.js.map

package/dist/ai.js.map

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

package/package.json

@@ -1,13 +1,45 @@
 {
   "name": "@cloudflare/codemode",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
+  "version": "0.0.4",
+  "description": "Code Mode: use LLMs to generate executable code that performs tool calls",
+  "repository": {
+    "directory": "packages/codemode",
+    "type": "git",
+    "url": "git+https://github.com/cloudflare/agents.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cloudflare/agents/issues"
+  },
+  "dependencies": {
+    "zod-to-ts": "^2.0.0"
+  },
+  "devDependencies": {
+    "ai": "^6.0.15",
+    "zod": "^4.3.5"
+  },
+  "peerDependencies": {
+    "agents": "^0.3.4",
+    "ai": "^6.0.0",
+    "zod": "^3.25.0 || ^4.0.0"
+  },
+  "exports": {
+    "./ai": {
+      "types": "./dist/ai.d.ts",
+      "import": "./dist/ai.js",
+      "require": "./dist/ai.js"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsx ./scripts/build.ts"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "commonjs"
+  "keywords": [
+    "cloudflare",
+    "agents",
+    "ai",
+    "llm",
+    "codemode"
+  ],
+  "author": "Cloudflare Inc.",
+  "license": "MIT",
+  "type": "module"
 }

package/scripts/build.ts

@@ -0,0 +1,26 @@
+import { execSync } from "node:child_process";
+import { build } from "tsdown";
+
+async function main() {
+  await build({
+    clean: true,
+    dts: true,
+    entry: ["src/ai.ts"],
+    skipNodeModulesBundle: true,
+    external: ["cloudflare:workers"],
+    format: "esm",
+    sourcemap: true,
+    fixedExtension: false
+  });
+
+  // then run prettier on the generated .d.ts files
+  execSync("prettier --write ./dist/*.d.ts");
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  // Build failures should fail
+  console.error(err);
+  process.exit(1);
+});

package/src/ai.ts

@@ -0,0 +1,245 @@
+import { generateObject, tool, type ToolSet } from "ai";
+import { openai } from "@ai-sdk/openai";
+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";
+
+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>;
+}): Promise<{
+  prompt: string;
+  tools: ToolSet;
+}> {
+  const generatedTypes = await generateTypes(options.tools);
+  const 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: 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("");
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "exclude": ["src/tests/**/*.ts", "src/e2e/**/*.ts"],
+  "extends": "../../tsconfig.base.json"
+}