@tanstack/ai-isolate-cloudflare 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/esm/index.d.ts

@@ -15,5 +15,6 @@
  *
  * @packageDocumentation
  */
-export { createCloudflareIsolateDriver, type CloudflareIsolateDriverConfig, } from './isolate-driver.js';
-export type { ExecuteRequest, ExecuteResponse, ToolSchema, ToolCallRequest, ToolResultPayload, } from './types.js';
+export { createCloudflareIsolateDriver, type CloudflareIsolateDriverConfig, } from './isolate-driver';
+export type { ExecuteRequest, ExecuteResponse, ToolSchema, ToolCallRequest, ToolResultPayload, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,6BAA6B,EAC7B,KAAK,6BAA6B,GACnC,MAAM,kBAAkB,CAAA;AAEzB,YAAY,EACV,cAAc,EACd,eAAe,EACf,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,SAAS,CAAA"}

package/dist/esm/index.js

@@ -1,5 +1,18 @@
-import { createCloudflareIsolateDriver } from "./isolate-driver.js";
-export {
-  createCloudflareIsolateDriver
-};
-//# sourceMappingURL=index.js.map
+/**
+ * @tanstack/ai-isolate-cloudflare
+ *
+ * Cloudflare Workers driver for TanStack AI Code Mode.
+ * Execute LLM-generated code on Cloudflare's global edge network.
+ *
+ * @example
+ * ```typescript
+ * import { createCloudflareIsolateDriver } from '@tanstack/ai-isolate-cloudflare'
+ *
+ * const driver = createCloudflareIsolateDriver({
+ *   workerUrl: 'https://your-worker.workers.dev',
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createCloudflareIsolateDriver, } from './isolate-driver';

package/dist/esm/isolate-driver.d.ts

@@ -1,4 +1,4 @@
-import { IsolateDriver } from '@tanstack/ai-code-mode';
+import type { IsolateDriver } from '@tanstack/ai-code-mode';
 /**
  * Configuration for the Cloudflare Workers isolate driver
  */
@@ -70,3 +70,4 @@ export interface CloudflareIsolateDriverConfig {
  * ```
  */
 export declare function createCloudflareIsolateDriver(config: CloudflareIsolateDriverConfig): IsolateDriver;
+//# sourceMappingURL=isolate-driver.d.ts.map

package/dist/esm/isolate-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isolate-driver.d.ts","sourceRoot":"","sources":["../../src/isolate-driver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,aAAa,EAEd,MAAM,wBAAwB,CAAA;AAQ/B;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAsMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,6BAA6B,GACpC,aAAa,CAuBf"}

package/dist/esm/isolate-driver.js

@@ -1,174 +1,220 @@
+/**
+ * Convert tool bindings to schemas for the Worker
+ */
 function bindingsToSchemas(bindings) {
-  return Object.entries(bindings).map(([name, binding]) => ({
-    name,
-    description: binding.description,
-    inputSchema: binding.inputSchema
-  }));
+    return Object.entries(bindings).map(([name, binding]) => ({
+        name,
+        description: binding.description,
+        inputSchema: binding.inputSchema,
+    }));
 }
+/**
+ * Normalize errors from various sources
+ */
 function normalizeError(error) {
-  if (error instanceof Error) {
-    return { name: error.name, message: error.message };
-  }
-  if (typeof error === "object" && error !== null) {
-    const e = error;
-    return {
-      name: String(e.name || "Error"),
-      message: String(e.message || JSON.stringify(error))
-    };
-  }
-  return { name: "Error", message: String(error) };
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message };
+    }
+    if (typeof error === 'object' && error !== null) {
+        const e = error;
+        return {
+            name: String(e.name || 'Error'),
+            message: String(e.message || JSON.stringify(error)),
+        };
+    }
+    return { name: 'Error', message: String(error) };
 }
+/**
+ * IsolateContext implementation using Cloudflare Workers
+ */
 class CloudflareIsolateContext {
-  workerUrl;
-  authorization;
-  timeout;
-  maxToolRounds;
-  bindings;
-  disposed = false;
-  constructor(workerUrl, bindings, timeout, maxToolRounds, authorization) {
-    this.workerUrl = workerUrl;
-    this.bindings = bindings;
-    this.timeout = timeout;
-    this.maxToolRounds = maxToolRounds;
-    this.authorization = authorization;
-  }
-  async execute(code) {
-    if (this.disposed) {
-      return {
-        success: false,
-        error: {
-          name: "DisposedError",
-          message: "Context has been disposed"
-        },
-        logs: []
-      };
+    workerUrl;
+    authorization;
+    timeout;
+    maxToolRounds;
+    bindings;
+    disposed = false;
+    constructor(workerUrl, bindings, timeout, maxToolRounds, authorization) {
+        this.workerUrl = workerUrl;
+        this.bindings = bindings;
+        this.timeout = timeout;
+        this.maxToolRounds = maxToolRounds;
+        this.authorization = authorization;
     }
-    const tools = bindingsToSchemas(this.bindings);
-    let toolResults;
-    let allLogs = [];
-    let rounds = 0;
-    while (rounds < this.maxToolRounds) {
-      rounds++;
-      const request = {
-        code,
-        tools,
-        toolResults,
-        timeout: this.timeout
-      };
-      try {
-        const headers = {
-          "Content-Type": "application/json"
-        };
-        if (this.authorization) {
-          headers["Authorization"] = this.authorization;
-        }
-        const response = await fetch(this.workerUrl, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(request)
-        });
-        if (!response.ok) {
-          const errorText = await response.text();
-          return {
-            success: false,
-            error: {
-              name: "WorkerError",
-              message: `Worker returned ${response.status}: ${errorText}`
-            },
-            logs: allLogs
-          };
-        }
-        const result = await response.json();
-        if (result.status === "error") {
-          return {
-            success: false,
-            error: result.error,
-            logs: allLogs
-          };
-        }
-        if (result.status === "done") {
-          allLogs = [...allLogs, ...result.logs];
-          return {
-            success: result.success,
-            value: result.value,
-            error: result.error,
-            logs: allLogs
-          };
-        }
-        allLogs = [...allLogs, ...result.logs];
-        toolResults = {};
-        for (const toolCall of result.toolCalls) {
-          const binding = this.bindings[toolCall.name];
-          if (!binding) {
-            toolResults[toolCall.id] = {
-              success: false,
-              error: `Unknown tool: ${toolCall.name}`
-            };
-            continue;
-          }
-          try {
-            const toolResult = await binding.execute(toolCall.args);
-            toolResults[toolCall.id] = {
-              success: true,
-              value: toolResult
+    async execute(code) {
+        if (this.disposed) {
+            return {
+                success: false,
+                error: {
+                    name: 'DisposedError',
+                    message: 'Context has been disposed',
+                },
+                logs: [],
             };
-          } catch (toolError) {
-            const err = normalizeError(toolError);
-            toolResults[toolCall.id] = {
-              success: false,
-              error: err.message
+        }
+        const tools = bindingsToSchemas(this.bindings);
+        let toolResults;
+        let allLogs = [];
+        let rounds = 0;
+        // Request/response loop for tool callbacks
+        while (rounds < this.maxToolRounds) {
+            rounds++;
+            const request = {
+                code,
+                tools,
+                toolResults,
+                timeout: this.timeout,
             };
-          }
+            try {
+                const headers = {
+                    'Content-Type': 'application/json',
+                };
+                if (this.authorization) {
+                    headers['Authorization'] = this.authorization;
+                }
+                const response = await fetch(this.workerUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(request),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    return {
+                        success: false,
+                        error: {
+                            name: 'WorkerError',
+                            message: `Worker returned ${response.status}: ${errorText}`,
+                        },
+                        logs: allLogs,
+                    };
+                }
+                const result = await response.json();
+                if (result.status === 'error') {
+                    return {
+                        success: false,
+                        error: result.error,
+                        logs: allLogs,
+                    };
+                }
+                if (result.status === 'done') {
+                    allLogs = [...allLogs, ...result.logs];
+                    return {
+                        success: result.success,
+                        value: result.value,
+                        error: result.error,
+                        logs: allLogs,
+                    };
+                }
+                // status === 'need_tools'
+                // Collect logs from this round
+                allLogs = [...allLogs, ...result.logs];
+                // Execute tool calls locally
+                toolResults = {};
+                for (const toolCall of result.toolCalls) {
+                    const binding = this.bindings[toolCall.name];
+                    if (!binding) {
+                        toolResults[toolCall.id] = {
+                            success: false,
+                            error: `Unknown tool: ${toolCall.name}`,
+                        };
+                        continue;
+                    }
+                    try {
+                        const toolResult = await binding.execute(toolCall.args);
+                        toolResults[toolCall.id] = {
+                            success: true,
+                            value: toolResult,
+                        };
+                    }
+                    catch (toolError) {
+                        const err = normalizeError(toolError);
+                        toolResults[toolCall.id] = {
+                            success: false,
+                            error: err.message,
+                        };
+                    }
+                }
+                // Continue loop to send results back to Worker
+            }
+            catch (fetchError) {
+                const err = normalizeError(fetchError);
+                return {
+                    success: false,
+                    error: {
+                        name: 'NetworkError',
+                        message: `Failed to communicate with Worker: ${err.message}`,
+                    },
+                    logs: allLogs,
+                };
+            }
         }
-      } catch (fetchError) {
-        const err = normalizeError(fetchError);
+        // Max rounds exceeded
         return {
-          success: false,
-          error: {
-            name: "NetworkError",
-            message: `Failed to communicate with Worker: ${err.message}`
-          },
-          logs: allLogs
+            success: false,
+            error: {
+                name: 'MaxRoundsExceeded',
+                message: `Exceeded maximum tool callback rounds (${this.maxToolRounds})`,
+            },
+            logs: allLogs,
         };
-      }
     }
+    dispose() {
+        this.disposed = true;
+        return Promise.resolve();
+    }
+}
+/**
+ * Create a Cloudflare Workers isolate driver
+ *
+ * This driver executes code on Cloudflare's global edge network,
+ * providing true distributed execution capabilities.
+ *
+ * Tool calls are handled via a request/response loop:
+ * 1. Code is sent to the Worker
+ * 2. Worker executes until it needs a tool
+ * 3. Tool call is returned to the driver
+ * 4. Driver executes the tool locally
+ * 5. Result is sent back to the Worker
+ * 6. Worker continues execution
+ *
+ * @example
+ * ```typescript
+ * import { createCloudflareIsolateDriver } from '@tanstack/ai-isolate-cloudflare'
+ *
+ * // For local development with wrangler
+ * const driver = createCloudflareIsolateDriver({
+ *   workerUrl: 'http://localhost:8787',
+ * })
+ *
+ * // For production
+ * const driver = createCloudflareIsolateDriver({
+ *   workerUrl: 'https://code-mode-worker.your-account.workers.dev',
+ *   authorization: 'Bearer your-secret-token',
+ * })
+ *
+ * const context = await driver.createContext({
+ *   bindings: {
+ *     readFile: {
+ *       name: 'readFile',
+ *       description: 'Read a file',
+ *       inputSchema: { type: 'object', properties: { path: { type: 'string' } } },
+ *       execute: async ({ path }) => fs.readFile(path, 'utf-8'),
+ *     },
+ *   },
+ * })
+ *
+ * const result = await context.execute(`
+ *   const content = await readFile({ path: './data.json' })
+ *   return JSON.parse(content)
+ * `)
+ * ```
+ */
+export function createCloudflareIsolateDriver(config) {
+    const { workerUrl, authorization, timeout: defaultTimeout = 30000, maxToolRounds = 10, } = config;
     return {
-      success: false,
-      error: {
-        name: "MaxRoundsExceeded",
-        message: `Exceeded maximum tool callback rounds (${this.maxToolRounds})`
-      },
-      logs: allLogs
+        createContext(isolateConfig) {
+            const timeout = isolateConfig.timeout ?? defaultTimeout;
+            return Promise.resolve(new CloudflareIsolateContext(workerUrl, isolateConfig.bindings, timeout, maxToolRounds, authorization));
+        },
     };
-  }
-  dispose() {
-    this.disposed = true;
-    return Promise.resolve();
-  }
-}
-function createCloudflareIsolateDriver(config) {
-  const {
-    workerUrl,
-    authorization,
-    timeout: defaultTimeout = 3e4,
-    maxToolRounds = 10
-  } = config;
-  return {
-    createContext(isolateConfig) {
-      const timeout = isolateConfig.timeout ?? defaultTimeout;
-      return Promise.resolve(
-        new CloudflareIsolateContext(
-          workerUrl,
-          isolateConfig.bindings,
-          timeout,
-          maxToolRounds,
-          authorization
-        )
-      );
-    }
-  };
 }
-export {
-  createCloudflareIsolateDriver
-};
-//# sourceMappingURL=isolate-driver.js.map

package/dist/esm/types.d.ts

@@ -70,3 +70,4 @@ export type ExecuteResponse = {
         message: string;
     };
 };
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,kDAAkD;IAClD,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;IACxB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC/C,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,IAAI,EAAE,OAAO,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,OAAO,EAAE,OAAO,CAAA;IAChB,qCAAqC;IACrC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB;IACE,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CACpB,GACD;IACE,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACjC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACnB,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAA;CACvB,GACD;IACE,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA"}

package/dist/esm/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types between the Cloudflare Worker and the driver
+ */
+export {};

package/dist/esm/worker/index.d.ts

@@ -33,3 +33,4 @@ declare const _default: {
     fetch(request: Request, env: Env, _ctx: ExecutionContext): Promise<Response>;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/worker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH;;;GAGG;AACH,UAAU,UAAU;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAChC;AAED,UAAU,GAAG;IACX;;;OAGG;IACH,WAAW,CAAC,EAAE,UAAU,CAAA;CACzB;AAmGD;;GAEG;;mBAGU,OAAO,OACX,GAAG,QACF,gBAAgB,GACrB,OAAO,CAAC,QAAQ,CAAC;;AALtB,wBAwEC"}

package/dist/esm/worker/index.js

@@ -1,132 +1,158 @@
-import { wrapCode } from "./wrap-code.js";
+/**
+ * Cloudflare Worker for Code Mode execution
+ *
+ * This Worker executes JavaScript code in a V8 isolate on Cloudflare's edge network.
+ * Tool calls are handled via a request/response loop with the driver.
+ *
+ * Flow:
+ * 1. Receive code + tool schemas
+ * 2. Execute code, collecting any tool calls
+ * 3. If tool calls are needed, return them to the driver
+ * 4. Driver executes tools locally, sends results back
+ * 5. Re-execute with tool results injected
+ * 6. Return final result
+ */
+import { wrapCode } from './wrap-code';
+/**
+ * Execute code in the Worker's V8 isolate
+ */
 async function executeCode(request, env) {
-  const { code, tools, toolResults, timeout = 3e4 } = request;
-  if (!env.UNSAFE_EVAL) {
-    return {
-      status: "error",
-      error: {
-        name: "UnsafeEvalNotAvailable",
-        message: "UNSAFE_EVAL binding is not available. This Worker requires the unsafe_eval binding for local development. For production, consider using Workers for Platforms."
-      }
-    };
-  }
-  try {
-    const wrappedCode = wrapCode(code, tools, toolResults);
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const result = await env.UNSAFE_EVAL.eval(wrappedCode);
-      clearTimeout(timeoutId);
-      if (result.status === "need_tools") {
+    const { code, tools, toolResults, timeout = 30000 } = request;
+    // Check if UNSAFE_EVAL binding is available
+    if (!env.UNSAFE_EVAL) {
         return {
-          status: "need_tools",
-          toolCalls: result.toolCalls || [],
-          logs: result.logs,
-          continuationId: crypto.randomUUID()
+            status: 'error',
+            error: {
+                name: 'UnsafeEvalNotAvailable',
+                message: 'UNSAFE_EVAL binding is not available. ' +
+                    'This Worker requires the unsafe_eval binding for local development. ' +
+                    'For production, consider using Workers for Platforms.',
+            },
         };
-      }
-      return {
-        status: "done",
-        success: result.success ?? false,
-        value: result.value,
-        error: result.error,
-        logs: result.logs
-      };
-    } catch (evalError) {
-      clearTimeout(timeoutId);
-      if (controller.signal.aborted) {
+    }
+    try {
+        const wrappedCode = wrapCode(code, tools, toolResults);
+        // Execute with timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            // Use UNSAFE_EVAL binding to execute the code
+            // This is only available in local development with wrangler dev
+            const result = (await env.UNSAFE_EVAL.eval(wrappedCode));
+            clearTimeout(timeoutId);
+            if (result.status === 'need_tools') {
+                return {
+                    status: 'need_tools',
+                    toolCalls: result.toolCalls || [],
+                    logs: result.logs,
+                    continuationId: crypto.randomUUID(),
+                };
+            }
+            return {
+                status: 'done',
+                success: result.success ?? false,
+                value: result.value,
+                error: result.error,
+                logs: result.logs,
+            };
+        }
+        catch (evalError) {
+            clearTimeout(timeoutId);
+            if (controller.signal.aborted) {
+                return {
+                    status: 'error',
+                    error: {
+                        name: 'TimeoutError',
+                        message: `Execution timed out after ${timeout}ms`,
+                    },
+                };
+            }
+            const error = evalError;
+            return {
+                status: 'done',
+                success: false,
+                error: {
+                    name: error.name || 'EvalError',
+                    message: error.message || String(error),
+                    stack: error.stack,
+                },
+                logs: [],
+            };
+        }
+    }
+    catch (error) {
+        const err = error;
         return {
-          status: "error",
-          error: {
-            name: "TimeoutError",
-            message: `Execution timed out after ${timeout}ms`
-          }
+            status: 'error',
+            error: {
+                name: err.name || 'Error',
+                message: err.message || String(err),
+            },
         };
-      }
-      const error = evalError;
-      return {
-        status: "done",
-        success: false,
-        error: {
-          name: error.name || "EvalError",
-          message: error.message || String(error),
-          stack: error.stack
-        },
-        logs: []
-      };
     }
-  } catch (error) {
-    const err = error;
-    return {
-      status: "error",
-      error: {
-        name: err.name || "Error",
-        message: err.message || String(err)
-      }
-    };
-  }
 }
-const index = {
-  async fetch(request, env, _ctx) {
-    if (request.method === "OPTIONS") {
-      return new Response(null, {
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "POST, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+/**
+ * Main Worker fetch handler
+ */
+export default {
+    async fetch(request, env, _ctx) {
+        // Handle CORS preflight
+        if (request.method === 'OPTIONS') {
+            return new Response(null, {
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                },
+            });
         }
-      });
-    }
-    if (request.method !== "POST") {
-      return new Response(JSON.stringify({ error: "Method not allowed" }), {
-        status: 405,
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*"
+        // Only accept POST requests
+        if (request.method !== 'POST') {
+            return new Response(JSON.stringify({ error: 'Method not allowed' }), {
+                status: 405,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            });
         }
-      });
-    }
-    try {
-      const body = await request.json();
-      if (!body.code || typeof body.code !== "string") {
-        return new Response(JSON.stringify({ error: "Code is required" }), {
-          status: 400,
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*"
-          }
-        });
-      }
-      const result = await executeCode(body, env);
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*"
+        try {
+            const body = await request.json();
+            // Validate request
+            if (!body.code || typeof body.code !== 'string') {
+                return new Response(JSON.stringify({ error: 'Code is required' }), {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Allow-Origin': '*',
+                    },
+                });
+            }
+            // Execute the code
+            const result = await executeCode(body, env);
+            return new Response(JSON.stringify(result), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            });
         }
-      });
-    } catch (error) {
-      const err = error;
-      return new Response(
-        JSON.stringify({
-          status: "error",
-          error: {
-            name: "RequestError",
-            message: err.message || "Failed to process request"
-          }
-        }),
-        {
-          status: 500,
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*"
-          }
+        catch (error) {
+            const err = error;
+            return new Response(JSON.stringify({
+                status: 'error',
+                error: {
+                    name: 'RequestError',
+                    message: err.message || 'Failed to process request',
+                },
+            }), {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+            });
         }
-      );
-    }
-  }
-};
-export {
-  index as default
+    },
 };
-//# sourceMappingURL=index.js.map

package/dist/esm/worker/wrap-code.d.ts

@@ -1,4 +1,8 @@
-import { ToolResultPayload, ToolSchema } from '../types.js';
+/**
+ * Code wrapping utilities for the Cloudflare Worker.
+ * Extracted for testability without UNSAFE_EVAL.
+ */
+import type { ToolResultPayload, ToolSchema } from '../types';
 /**
  * Generate tool wrapper code that collects calls or returns cached results.
  *
@@ -11,3 +15,4 @@ export declare function generateToolWrappers(tools: Array<ToolSchema>, toolResul
  * Wrap user code in an async IIFE with tool wrappers
  */
 export declare function wrapCode(code: string, tools: Array<ToolSchema>, toolResults?: Record<string, ToolResultPayload>): string;
+//# sourceMappingURL=wrap-code.d.ts.map

package/dist/esm/worker/wrap-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-code.d.ts","sourceRoot":"","sources":["../../../src/worker/wrap-code.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,EACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC9C,MAAM,CA+BR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,EACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC9C,MAAM,CAmER"}

package/dist/esm/worker/wrap-code.js

@@ -1,8 +1,19 @@
-function generateToolWrappers(tools, toolResults) {
-  const wrappers = [];
-  for (const tool of tools) {
-    if (toolResults) {
-      wrappers.push(`
+/**
+ * Code wrapping utilities for the Cloudflare Worker.
+ * Extracted for testability without UNSAFE_EVAL.
+ */
+/**
+ * Generate tool wrapper code that collects calls or returns cached results.
+ *
+ * Tool calls are identified by a sequential index (__toolCallIdx) rather than
+ * by hashing the input. This avoids mismatches when re-executing code whose
+ * inputs contain non-deterministic values (e.g. random UUIDs).
+ */
+export function generateToolWrappers(tools, toolResults) {
+    const wrappers = [];
+    for (const tool of tools) {
+        if (toolResults) {
+            wrappers.push(`
         async function ${tool.name}(input) {
           const callId = 'tc_' + (__toolCallIdx++);
           const result = __toolResults[callId];
@@ -16,22 +27,26 @@ function generateToolWrappers(tools, toolResults) {
           return result.value;
         }
       `);
-    } else {
-      wrappers.push(`
+        }
+        else {
+            wrappers.push(`
         async function ${tool.name}(input) {
           const callId = 'tc_' + (__toolCallIdx++);
           __pendingToolCalls.push({ id: callId, name: '${tool.name}', args: input });
           throw new __ToolCallNeeded(callId);
         }
       `);
+        }
     }
-  }
-  return wrappers.join("\n");
+    return wrappers.join('\n');
 }
-function wrapCode(code, tools, toolResults) {
-  const toolWrappers = generateToolWrappers(tools, toolResults);
-  const toolResultsJson = toolResults ? JSON.stringify(toolResults) : "{}";
-  return `
+/**
+ * Wrap user code in an async IIFE with tool wrappers
+ */
+export function wrapCode(code, tools, toolResults) {
+    const toolWrappers = generateToolWrappers(tools, toolResults);
+    const toolResultsJson = toolResults ? JSON.stringify(toolResults) : '{}';
+    return `
     (async function() {
       // Tool call tracking (sequential index for stable IDs across re-executions)
       let __toolCallIdx = 0;
@@ -95,8 +110,3 @@ function wrapCode(code, tools, toolResults) {
     })()
   `;
 }
-export {
-  generateToolWrappers,
-  wrapCode
-};
-//# sourceMappingURL=wrap-code.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-isolate-cloudflare",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Cloudflare Workers driver for TanStack AI Code Mode - execute code on the edge",
   "author": "",
   "license": "MIT",
@@ -9,9 +9,6 @@
     "url": "git+https://github.com/TanStack/ai.git",
     "directory": "packages/typescript/ai-isolate-cloudflare"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "type": "module",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -35,18 +32,6 @@
     "worker",
     "wrangler.toml"
   ],
-  "scripts": {
-    "build": "vite build",
-    "clean": "premove ./build ./dist",
-    "dev:worker": "node dev-server.mjs",
-    "deploy:worker": "wrangler deploy",
-    "lint:fix": "eslint ./src --fix",
-    "test:build": "publint --strict",
-    "test:eslint": "eslint ./src",
-    "test:lib": "vitest --passWithNoTests",
-    "test:lib:dev": "pnpm test:lib --watch",
-    "test:types": "tsc"
-  },
   "keywords": [
     "ai",
     "tanstack",
@@ -57,7 +42,7 @@
     "isolate"
   ],
   "dependencies": {
-    "@tanstack/ai-code-mode": "workspace:*"
+    "@tanstack/ai-code-mode": "0.1.1"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20241230.0",
@@ -65,5 +50,17 @@
     "esbuild": "^0.25.12",
     "miniflare": "^4.20260305.0",
     "wrangler": "^4.19.1"
+  },
+  "scripts": {
+    "build": "vite build",
+    "clean": "premove ./build ./dist",
+    "dev:worker": "node dev-server.mjs",
+    "deploy:worker": "wrangler deploy",
+    "lint:fix": "eslint ./src --fix",
+    "test:build": "publint --strict",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vitest --passWithNoTests",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "tsc"
   }
 }