@cloudflare/codemode 0.0.7 → 0.1.0

package/dist/ai.js

@@ -1,148 +1,79 @@
-import { generateObject, tool } from "ai";
+import { n as sanitizeToolName, t as generateTypes } from "./types-B9g5T2nd.js";
+import { tool } from "ai";
 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";
-import { openai } from "@ai-sdk/openai";
+import * as acorn from "acorn";
 
-//#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: `${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.
-  
-  `,
-		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: 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}      
+//#region src/tool.ts
+const DEFAULT_DESCRIPTION = `Execute code to achieve a goal.
 
-      Respond only with the code, nothing else. Output javascript code.
+Available:
+{{types}}
 
-      Generate an async function that achieves the goal. This async function doesn't accept any arguments.
+Write an async arrow function that returns the result.
+Do NOT define named functions then call them — just write the arrow function body directly.
 
-      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;
-				}
-			}
-		}) }
-	};
+Example: async () => { const r = await codemode.searchWeb({ query: "test" }); return r; }`;
+const codeSchema = z.object({ code: z.string().describe("JavaScript async arrow function to execute") });
+function normalizeCode(code) {
+	const trimmed = code.trim();
+	if (!trimmed) return "async () => {}";
+	try {
+		const ast = acorn.parse(trimmed, {
+			ecmaVersion: "latest",
+			sourceType: "module"
+		});
+		if (ast.body.length === 1 && ast.body[0].type === "ExpressionStatement") {
+			if (ast.body[0].expression.type === "ArrowFunctionExpression") return trimmed;
+		}
+		const last = ast.body[ast.body.length - 1];
+		if (last?.type === "ExpressionStatement") {
+			const exprStmt = last;
+			return `async () => {\n${trimmed.slice(0, last.start)}return (${trimmed.slice(exprStmt.expression.start, exprStmt.expression.end)})\n}`;
+		}
+		return `async () => {\n${trimmed}\n}`;
+	} catch {
+		return `async () => {\n${trimmed}\n}`;
+	}
 }
-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
-      };
-    }
-  }
+/**
+* Create a codemode tool that allows LLMs to write and execute code
+* with access to your tools in a sandboxed environment.
+*
+* Returns an AI SDK compatible tool.
+*/
+function hasNeedsApproval(t) {
+	return "needsApproval" in t && t.needsApproval != null;
 }
-            
-        ` },
-				env: { CodeModeProxy: options.proxy },
-				globalOutbound: null
+function createCodeTool(options) {
+	const tools = {};
+	for (const [name, t] of Object.entries(options.tools)) if (!hasNeedsApproval(t)) tools[name] = t;
+	const types = generateTypes(tools);
+	const executor = options.executor;
+	return tool({
+		description: (options.description ?? DEFAULT_DESCRIPTION).replace("{{types}}", types),
+		inputSchema: codeSchema,
+		execute: async ({ code }) => {
+			const fns = {};
+			for (const [name, t] of Object.entries(tools)) {
+				const execute = "execute" in t ? t.execute : void 0;
+				if (execute) fns[sanitizeToolName(name)] = execute;
+			}
+			const normalizedCode = normalizeCode(code);
+			const executeResult = await executor.execute(normalizedCode, fns);
+			if (executeResult.error) {
+				const logCtx = executeResult.logs?.length ? `\n\nConsole output:\n${executeResult.logs.join("\n")}` : "";
+				throw new Error(`Code execution failed: ${executeResult.error}${logCtx}`);
+			}
+			const output = {
+				code,
+				result: executeResult.result
 			};
-		}).getEntrypoint().evaluate();
-	};
-}
-async function generateTypes(tools) {
-	let availableTools = "";
-	let availableTypes = "";
-	for (const [toolName, tool] of Object.entries(tools)) {
-		const inputJsonType = tool.inputSchema.jsonSchema ? await compile(tool.inputSchema.jsonSchema, `${toCamelCase(toolName)}Input`, {
-			format: false,
-			bannerComment: " "
-		}) : printNode(createTypeAlias(zodToTs(tool.inputSchema, `${toCamelCase(toolName)}Input`).node, `${toCamelCase(toolName)}Input`));
-		const outputJsonType = tool.outputSchema?.jsonSchema ? await compile(tool.outputSchema?.jsonSchema, `${toCamelCase(toolName)}Output`, {
-			format: false,
-			bannerComment: " "
-		}) : tool.outputSchema ? printNode(createTypeAlias(zodToTs(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) {
-	return Object.entries(tools).map(([_toolName, tool]) => {
-		return `\n- ${tool.description?.trim()}`;
-	}).join("");
+			if (executeResult.logs) output.logs = executeResult.logs;
+			return output;
+		}
+	});
 }
 
 //#endregion
-export { CodeModeProxy, experimental_codemode };
+export { createCodeTool };
 //# sourceMappingURL=ai.js.map

package/dist/ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"ai.js","names":["compileJsonSchemaToTs","printNodeZodToTs"],"sources":["../src/ai.ts"],"sourcesContent":["import { generateObject, tool, type ToolSet, type LanguageModel } from \"ai\";\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\";\nimport { openai } from \"@ai-sdk/openai\";\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  model?: LanguageModel;\n}): Promise<{\n  prompt: string;\n  tools: ToolSet;\n}> {\n  const generatedTypes = await generateTypes(options.tools);\n  const prompt = `${options.prompt}\n  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: options.model ? options.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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"}
+{"version":3,"file":"ai.js","names":[],"sources":["../src/tool.ts"],"sourcesContent":["import { tool, type Tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { ToolSet } from \"ai\";\nimport * as acorn from \"acorn\";\nimport { generateTypes, sanitizeToolName, type ToolDescriptors } from \"./types\";\nimport type { Executor } from \"./executor\";\n\nconst DEFAULT_DESCRIPTION = `Execute code to achieve a goal.\n\nAvailable:\n{{types}}\n\nWrite an async arrow function that returns the result.\nDo NOT define named functions then call them — just write the arrow function body directly.\n\nExample: async () => { const r = await codemode.searchWeb({ query: \"test\" }); return r; }`;\n\nexport interface CreateCodeToolOptions {\n  tools: ToolDescriptors | ToolSet;\n  executor: Executor;\n  /**\n   * Custom tool description. Use {{types}} as a placeholder for the generated type definitions.\n   */\n  description?: string;\n}\n\nconst codeSchema = z.object({\n  code: z.string().describe(\"JavaScript async arrow function to execute\")\n});\n\ntype CodeInput = z.infer<typeof codeSchema>;\ntype CodeOutput = { code: string; result: unknown; logs?: string[] };\n\nfunction normalizeCode(code: string): string {\n  const trimmed = code.trim();\n  if (!trimmed) return \"async () => {}\";\n\n  try {\n    const ast = acorn.parse(trimmed, {\n      ecmaVersion: \"latest\",\n      sourceType: \"module\"\n    });\n\n    // Already an arrow function — pass through\n    if (ast.body.length === 1 && ast.body[0].type === \"ExpressionStatement\") {\n      const expr = (ast.body[0] as acorn.ExpressionStatement).expression;\n      if (expr.type === \"ArrowFunctionExpression\") return trimmed;\n    }\n\n    // Last statement is expression → splice in return\n    const last = ast.body[ast.body.length - 1];\n    if (last?.type === \"ExpressionStatement\") {\n      const exprStmt = last as acorn.ExpressionStatement;\n      const before = trimmed.slice(0, last.start);\n      const exprText = trimmed.slice(\n        exprStmt.expression.start,\n        exprStmt.expression.end\n      );\n      return `async () => {\\n${before}return (${exprText})\\n}`;\n    }\n\n    return `async () => {\\n${trimmed}\\n}`;\n  } catch {\n    return `async () => {\\n${trimmed}\\n}`;\n  }\n}\n\n/**\n * Create a codemode tool that allows LLMs to write and execute code\n * with access to your tools in a sandboxed environment.\n *\n * Returns an AI SDK compatible tool.\n */\nfunction hasNeedsApproval(t: Record<string, unknown>): boolean {\n  return \"needsApproval\" in t && t.needsApproval != null;\n}\n\nexport function createCodeTool(\n  options: CreateCodeToolOptions\n): Tool<CodeInput, CodeOutput> {\n  const tools: ToolDescriptors | ToolSet = {};\n  for (const [name, t] of Object.entries(options.tools)) {\n    if (!hasNeedsApproval(t as Record<string, unknown>)) {\n      (tools as Record<string, unknown>)[name] = t;\n    }\n  }\n\n  const types = generateTypes(tools);\n  const executor = options.executor;\n\n  const description = (options.description ?? DEFAULT_DESCRIPTION).replace(\n    \"{{types}}\",\n    types\n  );\n\n  return tool({\n    description,\n    inputSchema: codeSchema,\n    execute: async ({ code }) => {\n      // Extract execute functions from tools, keyed by name\n      const fns: Record<string, (...args: unknown[]) => Promise<unknown>> = {};\n\n      for (const [name, t] of Object.entries(tools)) {\n        const execute =\n          \"execute\" in t\n            ? (t.execute as (args: unknown) => Promise<unknown>)\n            : undefined;\n        if (execute) {\n          fns[sanitizeToolName(name)] = execute;\n        }\n      }\n\n      const normalizedCode = normalizeCode(code);\n\n      const executeResult = await executor.execute(normalizedCode, fns);\n\n      if (executeResult.error) {\n        const logCtx = executeResult.logs?.length\n          ? `\\n\\nConsole output:\\n${executeResult.logs.join(\"\\n\")}`\n          : \"\";\n        throw new Error(\n          `Code execution failed: ${executeResult.error}${logCtx}`\n        );\n      }\n\n      const output: CodeOutput = { code, result: executeResult.result };\n      if (executeResult.logs) output.logs = executeResult.logs;\n      return output;\n    }\n  });\n}\n"],"mappings":";;;;;;AAOA,MAAM,sBAAsB;;;;;;;;;AAmB5B,MAAM,aAAa,EAAE,OAAO,EAC1B,MAAM,EAAE,QAAQ,CAAC,SAAS,6CAA6C,EACxE,CAAC;AAKF,SAAS,cAAc,MAAsB;CAC3C,MAAM,UAAU,KAAK,MAAM;AAC3B,KAAI,CAAC,QAAS,QAAO;AAErB,KAAI;EACF,MAAM,MAAM,MAAM,MAAM,SAAS;GAC/B,aAAa;GACb,YAAY;GACb,CAAC;AAGF,MAAI,IAAI,KAAK,WAAW,KAAK,IAAI,KAAK,GAAG,SAAS,uBAEhD;OADc,IAAI,KAAK,GAAiC,WAC/C,SAAS,0BAA2B,QAAO;;EAItD,MAAM,OAAO,IAAI,KAAK,IAAI,KAAK,SAAS;AACxC,MAAI,MAAM,SAAS,uBAAuB;GACxC,MAAM,WAAW;AAMjB,UAAO,kBALQ,QAAQ,MAAM,GAAG,KAAK,MAAM,CAKX,UAJf,QAAQ,MACvB,SAAS,WAAW,OACpB,SAAS,WAAW,IACrB,CACkD;;AAGrD,SAAO,kBAAkB,QAAQ;SAC3B;AACN,SAAO,kBAAkB,QAAQ;;;;;;;;;AAUrC,SAAS,iBAAiB,GAAqC;AAC7D,QAAO,mBAAmB,KAAK,EAAE,iBAAiB;;AAGpD,SAAgB,eACd,SAC6B;CAC7B,MAAM,QAAmC,EAAE;AAC3C,MAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAAQ,QAAQ,MAAM,CACnD,KAAI,CAAC,iBAAiB,EAA6B,CACjD,CAAC,MAAkC,QAAQ;CAI/C,MAAM,QAAQ,cAAc,MAAM;CAClC,MAAM,WAAW,QAAQ;AAOzB,QAAO,KAAK;EACV,cANmB,QAAQ,eAAe,qBAAqB,QAC/D,aACA,MACD;EAIC,aAAa;EACb,SAAS,OAAO,EAAE,WAAW;GAE3B,MAAM,MAAgE,EAAE;AAExE,QAAK,MAAM,CAAC,MAAM,MAAM,OAAO,QAAQ,MAAM,EAAE;IAC7C,MAAM,UACJ,aAAa,IACR,EAAE,UACH;AACN,QAAI,QACF,KAAI,iBAAiB,KAAK,IAAI;;GAIlC,MAAM,iBAAiB,cAAc,KAAK;GAE1C,MAAM,gBAAgB,MAAM,SAAS,QAAQ,gBAAgB,IAAI;AAEjE,OAAI,cAAc,OAAO;IACvB,MAAM,SAAS,cAAc,MAAM,SAC/B,wBAAwB,cAAc,KAAK,KAAK,KAAK,KACrD;AACJ,UAAM,IAAI,MACR,0BAA0B,cAAc,QAAQ,SACjD;;GAGH,MAAM,SAAqB;IAAE;IAAM,QAAQ,cAAc;IAAQ;AACjE,OAAI,cAAc,KAAM,QAAO,OAAO,cAAc;AACpD,UAAO;;EAEV,CAAC"}

package/dist/executor-Czw9jKZH.d.ts

@@ -0,0 +1,96 @@
+import { RpcTarget } from "cloudflare:workers";
+import { ToolSet } from "ai";
+import { ZodType } from "zod";
+
+//#region src/types.d.ts
+/**
+ * Sanitize a tool name into a valid JavaScript identifier.
+ * Replaces hyphens, dots, and spaces with `_`, strips other invalid chars,
+ * prefixes digit-leading names with `_`, and appends `_` to JS reserved words.
+ */
+declare function sanitizeToolName(name: string): string;
+interface ToolDescriptor {
+  description?: string;
+  inputSchema: ZodType;
+  outputSchema?: ZodType;
+  execute?: (args: unknown) => Promise<unknown>;
+}
+type ToolDescriptors = Record<string, ToolDescriptor>;
+/**
+ * Generate TypeScript type definitions from tool descriptors or an AI SDK ToolSet.
+ * These types can be included in tool descriptions to help LLMs write correct code.
+ */
+declare function generateTypes(tools: ToolDescriptors | ToolSet): string;
+//#endregion
+//#region src/executor.d.ts
+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`.
+ */
+interface Executor {
+  execute(
+    code: string,
+    fns: Record<string, (...args: unknown[]) => Promise<unknown>>
+  ): Promise<ExecuteResult>;
+}
+/**
+ * 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.
+ */
+declare class ToolDispatcher extends RpcTarget {
+  #private;
+  constructor(fns: Record<string, (...args: unknown[]) => Promise<unknown>>);
+  call(name: string, argsJson: string): Promise<string>;
+}
+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.
+ */
+declare class DynamicWorkerExecutor implements Executor {
+  #private;
+  constructor(options: DynamicWorkerExecutorOptions);
+  execute(
+    code: string,
+    fns: Record<string, (...args: unknown[]) => Promise<unknown>>
+  ): Promise<ExecuteResult>;
+}
+//#endregion
+export {
+  ToolDispatcher as a,
+  generateTypes as c,
+  Executor as i,
+  sanitizeToolName as l,
+  DynamicWorkerExecutorOptions as n,
+  ToolDescriptor as o,
+  ExecuteResult as r,
+  ToolDescriptors as s,
+  DynamicWorkerExecutor as t
+};
+//# sourceMappingURL=executor-Czw9jKZH.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import {
+  a as ToolDispatcher,
+  c as generateTypes,
+  i as Executor,
+  l as sanitizeToolName,
+  n as DynamicWorkerExecutorOptions,
+  o as ToolDescriptor,
+  r as ExecuteResult,
+  s as ToolDescriptors,
+  t as DynamicWorkerExecutor
+} from "./executor-Czw9jKZH.js";
+export {
+  DynamicWorkerExecutor,
+  type DynamicWorkerExecutorOptions,
+  type ExecuteResult,
+  type Executor,
+  type ToolDescriptor,
+  type ToolDescriptors,
+  ToolDispatcher,
+  generateTypes,
+  sanitizeToolName
+};

package/dist/index.js

@@ -0,0 +1,109 @@
+import { n as sanitizeToolName, t as generateTypes } from "./types-B9g5T2nd.js";
+import { RpcTarget } from "cloudflare:workers";
+
+//#region src/executor.ts
+/**
+* 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.).
+*/
+/**
+* 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.
+*/
+var ToolDispatcher = class extends RpcTarget {
+	#fns;
+	constructor(fns) {
+		super();
+		this.#fns = fns;
+	}
+	async call(name, argsJson) {
+		const fn = this.#fns[name];
+		if (!fn) return JSON.stringify({ error: `Tool "${name}" not found` });
+		try {
+			const result = await fn(argsJson ? JSON.parse(argsJson) : {});
+			return JSON.stringify({ result });
+		} catch (err) {
+			return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+};
+/**
+* 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.
+*/
+var DynamicWorkerExecutor = class {
+	#loader;
+	#timeout;
+	#globalOutbound;
+	constructor(options) {
+		this.#loader = options.loader;
+		this.#timeout = options.timeout ?? 3e4;
+		this.#globalOutbound = options.globalOutbound ?? null;
+	}
+	async execute(code, fns) {
+		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 response = await this.#loader.get(`codemode-${crypto.randomUUID()}`, () => ({
+			compatibilityDate: "2025-06-01",
+			compatibilityFlags: ["nodejs_compat"],
+			mainModule: "executor.js",
+			modules: { "executor.js": executorModule },
+			globalOutbound: this.#globalOutbound
+		})).getEntrypoint().evaluate(dispatcher);
+		if (response.error) return {
+			result: void 0,
+			error: response.error,
+			logs: response.logs
+		};
+		return {
+			result: response.result,
+			logs: response.logs
+		};
+	}
+};
+
+//#endregion
+export { DynamicWorkerExecutor, ToolDispatcher, generateTypes, sanitizeToolName };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#fns","#loader","#timeout","#globalOutbound"],"sources":["../src/executor.ts"],"sourcesContent":["/**\n * Executor interface and DynamicWorkerExecutor implementation.\n *\n * The Executor interface is the core abstraction — implement it to run\n * LLM-generated code in any sandbox (Workers, QuickJS, Node VM, etc.).\n */\n\nimport { RpcTarget } from \"cloudflare:workers\";\n\nexport interface ExecuteResult {\n  result: unknown;\n  error?: string;\n  logs?: string[];\n}\n\n/**\n * An executor runs LLM-generated code in a sandbox, making the provided\n * tool functions callable as `codemode.*` inside the sandbox.\n *\n * Implementations should never throw — errors are returned in `ExecuteResult.error`.\n */\nexport interface Executor {\n  execute(\n    code: string,\n    fns: Record<string, (...args: unknown[]) => Promise<unknown>>\n  ): Promise<ExecuteResult>;\n}\n\n// -- ToolDispatcher (RPC target for tool calls from sandboxed Workers) --\n\n/**\n * An RpcTarget that dispatches tool calls from the sandboxed Worker\n * back to the host. Passed via Workers RPC to the dynamic Worker's\n * evaluate() method — no globalOutbound or Fetcher bindings needed.\n */\nexport class ToolDispatcher extends RpcTarget {\n  #fns: Record<string, (...args: unknown[]) => Promise<unknown>>;\n\n  constructor(fns: Record<string, (...args: unknown[]) => Promise<unknown>>) {\n    super();\n    this.#fns = fns;\n  }\n\n  async call(name: string, argsJson: string): Promise<string> {\n    const fn = this.#fns[name];\n    if (!fn) {\n      return JSON.stringify({ error: `Tool \"${name}\" not found` });\n    }\n    try {\n      const args = argsJson ? JSON.parse(argsJson) : {};\n      const result = await fn(args);\n      return JSON.stringify({ result });\n    } catch (err) {\n      return JSON.stringify({\n        error: err instanceof Error ? err.message : String(err)\n      });\n    }\n  }\n}\n\n// -- DynamicWorkerExecutor (Cloudflare Workers) --\n\nexport interface DynamicWorkerExecutorOptions {\n  loader: WorkerLoader;\n  /**\n   * Timeout in milliseconds for code execution. Defaults to 30000 (30s).\n   */\n  timeout?: number;\n  /**\n   * Controls outbound network access from sandboxed code.\n   * - `null` (default): fetch() and connect() throw — sandbox is fully isolated.\n   * - `undefined`: inherits parent Worker's network access (full internet).\n   * - A `Fetcher`: all outbound requests route through this handler.\n   */\n  globalOutbound?: Fetcher | null;\n}\n\n/**\n * Executes code in an isolated Cloudflare Worker via WorkerLoader.\n * Tool calls are dispatched via Workers RPC — the host passes a\n * ToolDispatcher (RpcTarget) to the Worker's evaluate() method.\n *\n * External fetch() and connect() are blocked by default via\n * `globalOutbound: null` (runtime-enforced). Pass a Fetcher to\n * `globalOutbound` to allow controlled outbound access.\n */\nexport class DynamicWorkerExecutor implements Executor {\n  #loader: WorkerLoader;\n  #timeout: number;\n  #globalOutbound: Fetcher | null;\n\n  constructor(options: DynamicWorkerExecutorOptions) {\n    this.#loader = options.loader;\n    this.#timeout = options.timeout ?? 30000;\n    this.#globalOutbound = options.globalOutbound ?? null;\n  }\n\n  async execute(\n    code: string,\n    fns: Record<string, (...args: unknown[]) => Promise<unknown>>\n  ): Promise<ExecuteResult> {\n    const timeoutMs = this.#timeout;\n\n    const modulePrefix = [\n      'import { WorkerEntrypoint } from \"cloudflare:workers\";',\n      \"\",\n      \"export default class CodeExecutor extends WorkerEntrypoint {\",\n      \"  async evaluate(dispatcher) {\",\n      \"    const __logs = [];\",\n      '    console.log = (...a) => { __logs.push(a.map(String).join(\" \")); };',\n      '    console.warn = (...a) => { __logs.push(\"[warn] \" + a.map(String).join(\" \")); };',\n      '    console.error = (...a) => { __logs.push(\"[error] \" + a.map(String).join(\" \")); };',\n      \"    const codemode = new Proxy({}, {\",\n      \"      get: (_, toolName) => async (args) => {\",\n      \"        const resJson = await dispatcher.call(String(toolName), JSON.stringify(args ?? {}));\",\n      \"        const data = JSON.parse(resJson);\",\n      \"        if (data.error) throw new Error(data.error);\",\n      \"        return data.result;\",\n      \"      }\",\n      \"    });\",\n      \"\",\n      \"    try {\",\n      \"      const result = await Promise.race([\",\n      \"        (\"\n    ].join(\"\\n\");\n\n    const moduleSuffix = [\n      \")(),\",\n      '        new Promise((_, reject) => setTimeout(() => reject(new Error(\"Execution timed out\")), ' +\n        timeoutMs +\n        \"))\",\n      \"      ]);\",\n      \"      return { result, logs: __logs };\",\n      \"    } catch (err) {\",\n      \"      return { result: undefined, error: err.message, logs: __logs };\",\n      \"    }\",\n      \"  }\",\n      \"}\"\n    ].join(\"\\n\");\n\n    const executorModule = modulePrefix + code + moduleSuffix;\n\n    const dispatcher = new ToolDispatcher(fns);\n\n    const worker = this.#loader.get(`codemode-${crypto.randomUUID()}`, () => ({\n      compatibilityDate: \"2025-06-01\",\n      compatibilityFlags: [\"nodejs_compat\"],\n      mainModule: \"executor.js\",\n      modules: {\n        \"executor.js\": executorModule\n      },\n      globalOutbound: this.#globalOutbound\n    }));\n\n    const entrypoint = worker.getEntrypoint() as unknown as {\n      evaluate(dispatcher: ToolDispatcher): Promise<{\n        result: unknown;\n        error?: string;\n        logs?: string[];\n      }>;\n    };\n    const response = await entrypoint.evaluate(dispatcher);\n\n    if (response.error) {\n      return { result: undefined, error: response.error, logs: response.logs };\n    }\n\n    return { result: response.result, logs: response.logs };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmCA,IAAa,iBAAb,cAAoC,UAAU;CAC5C;CAEA,YAAY,KAA+D;AACzE,SAAO;AACP,QAAKA,MAAO;;CAGd,MAAM,KAAK,MAAc,UAAmC;EAC1D,MAAM,KAAK,MAAKA,IAAK;AACrB,MAAI,CAAC,GACH,QAAO,KAAK,UAAU,EAAE,OAAO,SAAS,KAAK,cAAc,CAAC;AAE9D,MAAI;GAEF,MAAM,SAAS,MAAM,GADR,WAAW,KAAK,MAAM,SAAS,GAAG,EAAE,CACpB;AAC7B,UAAO,KAAK,UAAU,EAAE,QAAQ,CAAC;WAC1B,KAAK;AACZ,UAAO,KAAK,UAAU,EACpB,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACxD,CAAC;;;;;;;;;;;;;AA+BR,IAAa,wBAAb,MAAuD;CACrD;CACA;CACA;CAEA,YAAY,SAAuC;AACjD,QAAKC,SAAU,QAAQ;AACvB,QAAKC,UAAW,QAAQ,WAAW;AACnC,QAAKC,iBAAkB,QAAQ,kBAAkB;;CAGnD,MAAM,QACJ,MACA,KACwB;EACxB,MAAM,YAAY,MAAKD;EAEvB,MAAM,eAAe;GACnB;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CAAC,KAAK,KAAK;EAEZ,MAAM,eAAe;GACnB;GACA,qGACE,YACA;GACF;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CAAC,KAAK,KAAK;EAEZ,MAAM,iBAAiB,eAAe,OAAO;EAE7C,MAAM,aAAa,IAAI,eAAe,IAAI;EAmB1C,MAAM,WAAW,MAjBF,MAAKD,OAAQ,IAAI,YAAY,OAAO,YAAY,WAAW;GACxE,mBAAmB;GACnB,oBAAoB,CAAC,gBAAgB;GACrC,YAAY;GACZ,SAAS,EACP,eAAe,gBAChB;GACD,gBAAgB,MAAKE;GACtB,EAAE,CAEuB,eAAe,CAOP,SAAS,WAAW;AAEtD,MAAI,SAAS,MACX,QAAO;GAAE,QAAQ;GAAW,OAAO,SAAS;GAAO,MAAM,SAAS;GAAM;AAG1E,SAAO;GAAE,QAAQ,SAAS;GAAQ,MAAM,SAAS;GAAM"}

package/dist/types-B9g5T2nd.js

@@ -0,0 +1,138 @@
+import { createAuxiliaryTypeStore, createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+
+//#region src/types.ts
+const JS_RESERVED = new Set([
+	"abstract",
+	"arguments",
+	"await",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"undefined",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield"
+]);
+/**
+* Sanitize a tool name into a valid JavaScript identifier.
+* Replaces hyphens, dots, and spaces with `_`, strips other invalid chars,
+* prefixes digit-leading names with `_`, and appends `_` to JS reserved words.
+*/
+function sanitizeToolName(name) {
+	if (!name) return "_";
+	let sanitized = name.replace(/[-.\s]/g, "_");
+	sanitized = sanitized.replace(/[^a-zA-Z0-9_$]/g, "");
+	if (!sanitized) return "_";
+	if (/^[0-9]/.test(sanitized)) sanitized = "_" + sanitized;
+	if (JS_RESERVED.has(sanitized)) sanitized = sanitized + "_";
+	return sanitized;
+}
+function toCamelCase(str) {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/^[a-z]/, (letter) => letter.toUpperCase());
+}
+/**
+* Extract field descriptions from a Zod object schema's `.shape`, if available.
+* Returns an array of `@param input.fieldName - description` lines.
+*/
+function extractParamDescriptions(schema) {
+	const descriptions = [];
+	const shape = schema.shape;
+	if (!shape || typeof shape !== "object") return descriptions;
+	for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+		const desc = fieldSchema.description;
+		if (desc) descriptions.push(`@param input.${fieldName} - ${desc}`);
+	}
+	return descriptions;
+}
+/**
+* Generate TypeScript type definitions from tool descriptors or an AI SDK ToolSet.
+* These types can be included in tool descriptions to help LLMs write correct code.
+*/
+function generateTypes(tools) {
+	let availableTools = "";
+	let availableTypes = "";
+	const auxiliaryTypeStore = createAuxiliaryTypeStore();
+	for (const [toolName, tool] of Object.entries(tools)) {
+		const inputSchema = "inputSchema" in tool ? tool.inputSchema : tool.parameters;
+		const outputSchema = "outputSchema" in tool ? tool.outputSchema : void 0;
+		const description = tool.description;
+		const safeName = sanitizeToolName(toolName);
+		const inputType = printNode(createTypeAlias(zodToTs(inputSchema, { auxiliaryTypeStore }).node, `${toCamelCase(safeName)}Input`));
+		const outputType = outputSchema ? printNode(createTypeAlias(zodToTs(outputSchema, { auxiliaryTypeStore }).node, `${toCamelCase(safeName)}Output`)) : `type ${toCamelCase(safeName)}Output = unknown`;
+		availableTypes += `\n${inputType.trim()}`;
+		availableTypes += `\n${outputType.trim()}`;
+		const paramDescs = extractParamDescriptions(inputSchema);
+		const jsdocLines = [];
+		if (description?.trim()) jsdocLines.push(description.trim());
+		else jsdocLines.push(toolName);
+		for (const pd of paramDescs) jsdocLines.push(pd);
+		const jsdocBody = jsdocLines.map((l) => `\t * ${l}`).join("\n");
+		availableTools += `\n\t/**\n${jsdocBody}\n\t */`;
+		availableTools += `\n\t${safeName}: (input: ${toCamelCase(safeName)}Input) => Promise<${toCamelCase(safeName)}Output>;`;
+		availableTools += "\n";
+	}
+	availableTools = `\ndeclare const codemode: {${availableTools}}`;
+	return `
+${availableTypes}
+${availableTools}
+  `.trim();
+}
+
+//#endregion
+export { sanitizeToolName as n, generateTypes as t };
+//# sourceMappingURL=types-B9g5T2nd.js.map