@cloudflare/codemode 0.0.8 → 0.1.0

package/dist/types-B9g5T2nd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-B9g5T2nd.js","names":["printNodeZodToTs"],"sources":["../src/types.ts"],"sourcesContent":["import {\n  zodToTs,\n  printNode as printNodeZodToTs,\n  createTypeAlias,\n  createAuxiliaryTypeStore\n} from \"zod-to-ts\";\nimport type { ZodType } from \"zod\";\nimport type { ToolSet } from \"ai\";\n\nconst JS_RESERVED = new Set([\n  \"abstract\",\n  \"arguments\",\n  \"await\",\n  \"boolean\",\n  \"break\",\n  \"byte\",\n  \"case\",\n  \"catch\",\n  \"char\",\n  \"class\",\n  \"const\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"delete\",\n  \"do\",\n  \"double\",\n  \"else\",\n  \"enum\",\n  \"eval\",\n  \"export\",\n  \"extends\",\n  \"false\",\n  \"final\",\n  \"finally\",\n  \"float\",\n  \"for\",\n  \"function\",\n  \"goto\",\n  \"if\",\n  \"implements\",\n  \"import\",\n  \"in\",\n  \"instanceof\",\n  \"int\",\n  \"interface\",\n  \"let\",\n  \"long\",\n  \"native\",\n  \"new\",\n  \"null\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"return\",\n  \"short\",\n  \"static\",\n  \"super\",\n  \"switch\",\n  \"synchronized\",\n  \"this\",\n  \"throw\",\n  \"throws\",\n  \"transient\",\n  \"true\",\n  \"try\",\n  \"typeof\",\n  \"undefined\",\n  \"var\",\n  \"void\",\n  \"volatile\",\n  \"while\",\n  \"with\",\n  \"yield\"\n]);\n\n/**\n * Sanitize a tool name into a valid JavaScript identifier.\n * Replaces hyphens, dots, and spaces with `_`, strips other invalid chars,\n * prefixes digit-leading names with `_`, and appends `_` to JS reserved words.\n */\nexport function sanitizeToolName(name: string): string {\n  if (!name) return \"_\";\n\n  // Replace common separators with underscores\n  let sanitized = name.replace(/[-.\\s]/g, \"_\");\n\n  // Strip any remaining non-identifier characters\n  sanitized = sanitized.replace(/[^a-zA-Z0-9_$]/g, \"\");\n\n  if (!sanitized) return \"_\";\n\n  // Prefix with _ if starts with a digit\n  if (/^[0-9]/.test(sanitized)) {\n    sanitized = \"_\" + sanitized;\n  }\n\n  // Append _ to reserved words\n  if (JS_RESERVED.has(sanitized)) {\n    sanitized = sanitized + \"_\";\n  }\n\n  return sanitized;\n}\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\n/**\n * Extract field descriptions from a Zod object schema's `.shape`, if available.\n * Returns an array of `@param input.fieldName - description` lines.\n */\nfunction extractParamDescriptions(schema: ZodType): string[] {\n  const descriptions: string[] = [];\n  const shape = (schema as { shape?: Record<string, ZodType> }).shape;\n  if (!shape || typeof shape !== \"object\") return descriptions;\n\n  for (const [fieldName, fieldSchema] of Object.entries(shape)) {\n    const desc = (fieldSchema as { description?: string }).description;\n    if (desc) {\n      descriptions.push(`@param input.${fieldName} - ${desc}`);\n    }\n  }\n  return descriptions;\n}\n\nexport interface ToolDescriptor {\n  description?: string;\n  inputSchema: ZodType;\n  outputSchema?: ZodType;\n  execute?: (args: unknown) => Promise<unknown>;\n}\n\nexport type ToolDescriptors = Record<string, ToolDescriptor>;\n\n/**\n * Generate TypeScript type definitions from tool descriptors or an AI SDK ToolSet.\n * These types can be included in tool descriptions to help LLMs write correct code.\n */\nexport function generateTypes(tools: ToolDescriptors | ToolSet): string {\n  let availableTools = \"\";\n  let availableTypes = \"\";\n\n  const auxiliaryTypeStore = createAuxiliaryTypeStore();\n\n  for (const [toolName, tool] of Object.entries(tools)) {\n    // Handle both our ToolDescriptor and AI SDK Tool types\n    const inputSchema =\n      \"inputSchema\" in tool ? tool.inputSchema : tool.parameters;\n    const outputSchema = \"outputSchema\" in tool ? tool.outputSchema : undefined;\n    const description = tool.description;\n\n    const safeName = sanitizeToolName(toolName);\n\n    const inputType = printNodeZodToTs(\n      createTypeAlias(\n        zodToTs(inputSchema as ZodType, { auxiliaryTypeStore }).node,\n        `${toCamelCase(safeName)}Input`\n      )\n    );\n\n    const outputType = outputSchema\n      ? printNodeZodToTs(\n          createTypeAlias(\n            zodToTs(outputSchema as ZodType, { auxiliaryTypeStore }).node,\n            `${toCamelCase(safeName)}Output`\n          )\n        )\n      : `type ${toCamelCase(safeName)}Output = unknown`;\n\n    availableTypes += `\\n${inputType.trim()}`;\n    availableTypes += `\\n${outputType.trim()}`;\n\n    // Build JSDoc comment with description and param descriptions\n    const paramDescs = extractParamDescriptions(inputSchema as ZodType);\n    const jsdocLines: string[] = [];\n    if (description?.trim()) {\n      jsdocLines.push(description.trim());\n    } else {\n      jsdocLines.push(toolName);\n    }\n    for (const pd of paramDescs) {\n      jsdocLines.push(pd);\n    }\n\n    const jsdocBody = jsdocLines.map((l) => `\\t * ${l}`).join(\"\\n\");\n    availableTools += `\\n\\t/**\\n${jsdocBody}\\n\\t */`;\n    availableTools += `\\n\\t${safeName}: (input: ${toCamelCase(safeName)}Input) => Promise<${toCamelCase(safeName)}Output>;`;\n    availableTools += \"\\n\";\n  }\n\n  availableTools = `\\ndeclare const codemode: {${availableTools}}`;\n\n  return `\n${availableTypes}\n${availableTools}\n  `.trim();\n}\n"],"mappings":";;;AASA,MAAM,cAAc,IAAI,IAAI;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;AAOF,SAAgB,iBAAiB,MAAsB;AACrD,KAAI,CAAC,KAAM,QAAO;CAGlB,IAAI,YAAY,KAAK,QAAQ,WAAW,IAAI;AAG5C,aAAY,UAAU,QAAQ,mBAAmB,GAAG;AAEpD,KAAI,CAAC,UAAW,QAAO;AAGvB,KAAI,SAAS,KAAK,UAAU,CAC1B,aAAY,MAAM;AAIpB,KAAI,YAAY,IAAI,UAAU,CAC5B,aAAY,YAAY;AAG1B,QAAO;;AAGT,SAAS,YAAY,KAAa;AAChC,QAAO,IACJ,QAAQ,cAAc,GAAG,WAAW,OAAO,aAAa,CAAC,CACzD,QAAQ,WAAW,WAAW,OAAO,aAAa,CAAC;;;;;;AAOxD,SAAS,yBAAyB,QAA2B;CAC3D,MAAM,eAAyB,EAAE;CACjC,MAAM,QAAS,OAA+C;AAC9D,KAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAEhD,MAAK,MAAM,CAAC,WAAW,gBAAgB,OAAO,QAAQ,MAAM,EAAE;EAC5D,MAAM,OAAQ,YAAyC;AACvD,MAAI,KACF,cAAa,KAAK,gBAAgB,UAAU,KAAK,OAAO;;AAG5D,QAAO;;;;;;AAgBT,SAAgB,cAAc,OAA0C;CACtE,IAAI,iBAAiB;CACrB,IAAI,iBAAiB;CAErB,MAAM,qBAAqB,0BAA0B;AAErD,MAAK,MAAM,CAAC,UAAU,SAAS,OAAO,QAAQ,MAAM,EAAE;EAEpD,MAAM,cACJ,iBAAiB,OAAO,KAAK,cAAc,KAAK;EAClD,MAAM,eAAe,kBAAkB,OAAO,KAAK,eAAe;EAClE,MAAM,cAAc,KAAK;EAEzB,MAAM,WAAW,iBAAiB,SAAS;EAE3C,MAAM,YAAYA,UAChB,gBACE,QAAQ,aAAwB,EAAE,oBAAoB,CAAC,CAAC,MACxD,GAAG,YAAY,SAAS,CAAC,OAC1B,CACF;EAED,MAAM,aAAa,eACfA,UACE,gBACE,QAAQ,cAAyB,EAAE,oBAAoB,CAAC,CAAC,MACzD,GAAG,YAAY,SAAS,CAAC,QAC1B,CACF,GACD,QAAQ,YAAY,SAAS,CAAC;AAElC,oBAAkB,KAAK,UAAU,MAAM;AACvC,oBAAkB,KAAK,WAAW,MAAM;EAGxC,MAAM,aAAa,yBAAyB,YAAuB;EACnE,MAAM,aAAuB,EAAE;AAC/B,MAAI,aAAa,MAAM,CACrB,YAAW,KAAK,YAAY,MAAM,CAAC;MAEnC,YAAW,KAAK,SAAS;AAE3B,OAAK,MAAM,MAAM,WACf,YAAW,KAAK,GAAG;EAGrB,MAAM,YAAY,WAAW,KAAK,MAAM,QAAQ,IAAI,CAAC,KAAK,KAAK;AAC/D,oBAAkB,YAAY,UAAU;AACxC,oBAAkB,OAAO,SAAS,YAAY,YAAY,SAAS,CAAC,oBAAoB,YAAY,SAAS,CAAC;AAC9G,oBAAkB;;AAGpB,kBAAiB,8BAA8B,eAAe;AAE9D,QAAO;EACP,eAAe;EACf,eAAe;IACb,MAAM"}

package/e2e/codemode.spec.ts

@@ -0,0 +1,124 @@
+import { test, expect } from "@playwright/test";
+
+/**
+ * E2E tests for @cloudflare/codemode with a real AI binding.
+ *
+ * These verify the full pipeline:
+ *   user prompt → LLM generates code via createCodeTool → DynamicWorkerExecutor
+ *   runs the code in an isolated Worker → tool functions called via RPC → result returned.
+ *
+ * Uses Workers AI (@cf/zai-org/glm-4.7-flash) — no API key needed.
+ */
+
+async function runChat(
+  request: import("@playwright/test").APIRequestContext,
+  baseURL: string,
+  userMessage: string
+): Promise<string> {
+  const res = await request.post(`${baseURL}/run`, {
+    headers: { "Content-Type": "application/json" },
+    data: {
+      messages: [
+        {
+          id: `msg-${crypto.randomUUID()}`,
+          role: "user",
+          parts: [{ type: "text", text: userMessage }]
+        }
+      ]
+    },
+    timeout: 45_000
+  });
+  expect(res.ok()).toBe(true);
+  return res.text();
+}
+
+test.describe("codemode e2e (Workers AI)", () => {
+  test.setTimeout(45_000);
+
+  test("LLM generates and executes code that calls addNumbers tool", async ({
+    request,
+    baseURL
+  }) => {
+    const response = await runChat(
+      request,
+      baseURL!,
+      "What is 17 + 25? Use the codemode tool with the addNumbers function to calculate this."
+    );
+
+    // The response stream should contain the answer 42 somewhere
+    // (either in the tool result or the LLM's text response)
+    expect(response).toContain("42");
+  });
+
+  test("LLM generates and executes code that calls getWeather tool", async ({
+    request,
+    baseURL
+  }) => {
+    const response = await runChat(
+      request,
+      baseURL!,
+      "What is the weather in London? Use the codemode tool with the getWeather function."
+    );
+
+    // The getWeather tool returns { city: "London", temperature: 22, condition: "Sunny" }
+    // The LLM should mention London or the weather data in its response
+    const lower = response.toLowerCase();
+    expect(
+      lower.includes("london") ||
+        lower.includes("22") ||
+        lower.includes("sunny")
+    ).toBe(true);
+  });
+
+  test("LLM generates and executes code that calls listProjects tool", async ({
+    request,
+    baseURL
+  }) => {
+    const response = await runChat(
+      request,
+      baseURL!,
+      "List all projects using the codemode tool with the listProjects function."
+    );
+
+    // listProjects returns Alpha and Beta
+    const lower = response.toLowerCase();
+    expect(lower.includes("alpha") || lower.includes("beta")).toBe(true);
+  });
+
+  test("LLM generates code with multiple tool calls", async ({
+    request,
+    baseURL
+  }) => {
+    const response = await runChat(
+      request,
+      baseURL!,
+      "Using the codemode tool, first get the weather in Paris, then add the numbers 10 and 5. Return both results."
+    );
+
+    // Should contain evidence of both tool calls completing
+    const lower = response.toLowerCase();
+    expect(
+      lower.includes("paris") ||
+        lower.includes("22") ||
+        lower.includes("15") ||
+        lower.includes("sunny")
+    ).toBe(true);
+  });
+
+  test("generateTypes returns valid type definitions", async ({
+    request,
+    baseURL
+  }) => {
+    const res = await request.get(`${baseURL}/types`);
+    expect(res.ok()).toBe(true);
+
+    const data = await res.json();
+    const types = data.types as string;
+
+    expect(types).toContain("declare const codemode");
+    expect(types).toContain("addNumbers");
+    expect(types).toContain("getWeather");
+    expect(types).toContain("createProject");
+    expect(types).toContain("listProjects");
+  });
+});

package/e2e/playwright.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from "@playwright/test";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PORT = 8798;
+const e2eDir = dirname(fileURLToPath(import.meta.url));
+const configPath = join(e2eDir, "wrangler.jsonc");
+
+export default defineConfig({
+  testDir: e2eDir,
+  testMatch: "*.spec.ts",
+  timeout: 60_000,
+  retries: 2,
+  workers: 1,
+  use: {
+    baseURL: `http://localhost:${PORT}`
+  },
+  webServer: {
+    command: `lsof -ti tcp:${PORT} | xargs kill -9 2>/dev/null; npx wrangler dev --config ${configPath} --port ${PORT}`,
+    port: PORT,
+    reuseExistingServer: !process.env.CI,
+    timeout: 30_000
+  }
+});

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.0",
   "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.94",
+    "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";