fix: lazy-load PTC dependencies to fix CI failures

- Move typescript from devDependencies to dependencies (needed at runtime for PTC static analysis)
- Lazy-load PTC modules in aiService.ts using dynamic import()
- Only load code_execution, quickjsRuntime, and toolBridge when PTC experiments are enabled

This fixes two CI failures:
1. Integration tests failing due to prettier's dynamic imports requiring --experimental-vm-modules
2. Smoke tests failing because typescript wasn't in production bundle

The import chain (aiService → code_execution → staticAnalysis/typeGenerator → typescript/prettier)
now only executes when PTC is actually used.

Author: ethanndickson

bun.lock

@@ -70,6 +70,7 @@
         "streamdown": "1.6.10",
         "trpc-cli": "^0.12.1",
         "turndown": "^7.2.2",
+        "typescript": "^5.1.3",
         "undici": "^7.16.0",
         "write-file-atomic": "^6.0.0",
         "ws": "^8.18.3",
@@ -157,7 +158,6 @@
         "tailwindcss": "^4.1.15",
         "ts-jest": "^29.4.4",
         "tsc-alias": "^1.8.16",
-        "typescript": "^5.1.3",
         "typescript-eslint": "^8.45.0",
         "vite": "^7.1.11",
         "vite-plugin-svgr": "^4.5.0",

package.json

@@ -102,6 +102,7 @@
     "parse-duration": "^2.1.4",
     "posthog-node": "^5.17.0",
     "quickjs-emscripten": "^0.31.0",
+    "typescript": "^5.1.3",
     "quickjs-emscripten-core": "^0.31.0",
     "rehype-harden": "^1.1.5",
     "rehype-sanitize": "^6.0.0",
@@ -197,7 +198,6 @@
     "tailwindcss": "^4.1.15",
     "ts-jest": "^29.4.4",
     "tsc-alias": "^1.8.16",
-    "typescript": "^5.1.3",
     "typescript-eslint": "^8.45.0",
     "vite": "^7.1.11",
     "vite-plugin-svgr": "^4.5.0",

src/node/services/aiService.ts

@@ -57,11 +57,13 @@ import type {
   StreamStartEvent,
 } from "@/common/types/stream";
 import { applyToolPolicy, type ToolPolicy } from "@/common/utils/tools/toolPolicy";
-import {
-  createCodeExecutionTool,
-  type PTCEventWithParent,
+// PTC types only - modules lazy-loaded to avoid loading typescript/prettier at startup
+import type {
+  PTCEventWithParent,
+  createCodeExecutionTool as CreateCodeExecutionToolFn,
 } from "@/node/services/tools/code_execution";
-import { QuickJSRuntimeFactory } from "@/node/services/ptc/quickjsRuntime";
+import type { QuickJSRuntimeFactory } from "@/node/services/ptc/quickjsRuntime";
+import type { ToolBridge } from "@/node/services/ptc/toolBridge";
 import { MockScenarioPlayer } from "./mock/mockScenarioPlayer";
 import { EnvHttpProxyAgent, type Dispatcher } from "undici";
 import { getPlanFilePath } from "@/common/utils/planStorage";
@@ -115,11 +117,38 @@ type FetchWithBunExtensions = typeof fetch & {
 const globalFetchWithExtras = fetch as FetchWithBunExtensions;
 const defaultFetchWithExtras = defaultFetchWithUnlimitedTimeout as FetchWithBunExtensions;
 
-// Singleton QuickJS runtime factory for PTC (WASM module is expensive to load)
-let quickjsRuntimeFactory: QuickJSRuntimeFactory | null = null;
-function getQuickJSRuntimeFactory(): QuickJSRuntimeFactory {
-  quickjsRuntimeFactory ??= new QuickJSRuntimeFactory();
-  return quickjsRuntimeFactory;
+// Lazy-loaded PTC modules (only loaded when experiment is enabled)
+// This avoids loading typescript/prettier at startup which causes issues:
+// - Integration tests fail without --experimental-vm-modules (prettier uses dynamic imports)
+// - Smoke tests fail if typescript isn't in production bundle
+// Dynamic imports are justified: PTC pulls in ~10MB of dependencies that would slow startup.
+interface PTCModules {
+  createCodeExecutionTool: typeof CreateCodeExecutionToolFn;
+  QuickJSRuntimeFactory: typeof QuickJSRuntimeFactory;
+  ToolBridge: typeof ToolBridge;
+  runtimeFactory: QuickJSRuntimeFactory | null;
+}
+let ptcModules: PTCModules | null = null;
+
+async function getPTCModules(): Promise<PTCModules> {
+  if (ptcModules) return ptcModules;
+
+  /* eslint-disable no-restricted-syntax -- Dynamic imports required here to avoid loading
+     ~10MB of typescript/prettier/quickjs at startup (causes CI failures) */
+  const [codeExecution, quickjs, toolBridge] = await Promise.all([
+    import("@/node/services/tools/code_execution"),
+    import("@/node/services/ptc/quickjsRuntime"),
+    import("@/node/services/ptc/toolBridge"),
+  ]);
+  /* eslint-enable no-restricted-syntax */
+
+  ptcModules = {
+    createCodeExecutionTool: codeExecution.createCodeExecutionTool,
+    QuickJSRuntimeFactory: quickjs.QuickJSRuntimeFactory,
+    ToolBridge: toolBridge.ToolBridge,
+    runtimeFactory: null,
+  };
+  return ptcModules;
 }
 
 if (typeof globalFetchWithExtras.preconnect === "function") {
@@ -1254,6 +1283,9 @@ export class AIService extends EventEmitter {
       let toolsWithPTC = allTools;
       if (experiments?.programmaticToolCalling || experiments?.programmaticToolCallingExclusive) {
         try {
+          // Lazy-load PTC modules only when experiments are enabled
+          const ptc = await getPTCModules();
+
           // Create emit callback that forwards nested events to stream
           // Only forward tool-call-start/end events, not console events
           const emitNestedEvent = (event: PTCEventWithParent): void => {
@@ -1263,15 +1295,24 @@ export class AIService extends EventEmitter {
             // Console events are not streamed (appear in final result only)
           };
 
-          const codeExecutionTool = await createCodeExecutionTool(
-            getQuickJSRuntimeFactory(),
-            allTools, // All tools available inside sandbox
+          // ToolBridge determines which tools can be bridged into the sandbox
+          const toolBridge = new ptc.ToolBridge(allTools);
+
+          // Singleton runtime factory (WASM module is expensive to load)
+          ptc.runtimeFactory ??= new ptc.QuickJSRuntimeFactory();
+
+          const codeExecutionTool = await ptc.createCodeExecutionTool(
+            ptc.runtimeFactory,
+            toolBridge,
             emitNestedEvent
           );
 
           if (experiments?.programmaticToolCallingExclusive) {
-            // Exclusive mode: only code_execution available
-            toolsWithPTC = { code_execution: codeExecutionTool };
+            // Exclusive mode: code_execution + non-bridgeable tools (web_search, propose_plan, etc.)
+            // Non-bridgeable tools can't be used from within code_execution, so they're still
+            // available directly to the model
+            const nonBridgeable = toolBridge.getNonBridgeableTools();
+            toolsWithPTC = { ...nonBridgeable, code_execution: codeExecutionTool };
           } else {
             // Supplement mode: add code_execution alongside other tools
             toolsWithPTC = { ...allTools, code_execution: codeExecutionTool };

src/node/services/ptc/toolBridge.ts

@@ -24,18 +24,22 @@ const EXCLUDED_TOOLS = new Set([
  */
 export class ToolBridge {
   private readonly bridgeableTools: Map<string, Tool>;
+  private readonly nonBridgeableTools: Map<string, Tool>;
 
   constructor(tools: Record<string, Tool>) {
     this.bridgeableTools = new Map();
+    this.nonBridgeableTools = new Map();
 
     for (const [name, tool] of Object.entries(tools)) {
-      // Skip excluded tools
-      if (EXCLUDED_TOOLS.has(name)) continue;
-
-      // Skip tools without execute function (provider-native like web_search)
-      if (!this.hasExecute(tool)) continue;
-
-      this.bridgeableTools.set(name, tool);
+      // code_execution is the tool that uses the bridge, not a candidate for bridging
+      if (name === "code_execution") continue;
+
+      const isBridgeable = !EXCLUDED_TOOLS.has(name) && this.hasExecute(tool);
+      if (isBridgeable) {
+        this.bridgeableTools.set(name, tool);
+      } else {
+        this.nonBridgeableTools.set(name, tool);
+      }
     }
   }
 
@@ -49,6 +53,18 @@ export class ToolBridge {
     return Object.fromEntries(this.bridgeableTools.entries());
   }
 
+  /**
+   * Get tools that cannot be bridged into the sandbox.
+   * These are tools that either:
+   * - Are explicitly excluded (UI-specific, mode-specific)
+   * - Don't have an execute function (provider-native like web_search)
+   *
+   * In exclusive PTC mode, these should still be available to the model directly.
+   */
+  getNonBridgeableTools(): Record<string, Tool> {
+    return Object.fromEntries(this.nonBridgeableTools.entries());
+  }
+
   /** Register all bridgeable tools on the runtime under `mux` namespace */
   register(runtime: IJSRuntime, abortSignal?: AbortSignal): void {
     const muxObj: Record<string, (...args: unknown[]) => Promise<unknown>> = {};

src/node/services/tools/code_execution.integration.test.ts

@@ -15,6 +15,7 @@ import { createCodeExecutionTool } from "./code_execution";
 import { createFileReadTool } from "./file_read";
 import { createBashTool } from "./bash";
 import { QuickJSRuntimeFactory } from "@/node/services/ptc/quickjsRuntime";
+import { ToolBridge } from "@/node/services/ptc/toolBridge";
 import type { Tool, ToolCallOptions } from "ai";
 import type { PTCEvent, PTCExecutionResult, PTCToolCallEndEvent } from "@/node/services/ptc/types";
 import { createTestToolConfig, TestTempDir, getTestDeps } from "./testHelpers";
@@ -52,8 +53,10 @@ describe("code_execution integration tests", () => {
 
       // Track events
       const events: PTCEvent[] = [];
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools, (e) =>
-        events.push(e)
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools),
+        (e) => events.push(e)
       );
 
       // Execute code that reads the file
@@ -94,7 +97,10 @@ describe("code_execution integration tests", () => {
       const fileReadTool = createFileReadTool(toolConfig);
       const tools: Record<string, Tool> = { file_read: fileReadTool };
 
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools);
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools)
+      );
 
       const code = `
         const result = mux.file_read({ filePath: "nonexistent.txt" });
@@ -129,8 +135,10 @@ describe("code_execution integration tests", () => {
       const tools: Record<string, Tool> = { bash: bashTool };
 
       const events: PTCEvent[] = [];
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools, (e) =>
-        events.push(e)
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools),
+        (e) => events.push(e)
       );
 
       // Execute a simple echo command
@@ -182,8 +190,10 @@ describe("code_execution integration tests", () => {
       };
 
       const events: PTCEvent[] = [];
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools, (e) =>
-        events.push(e)
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools),
+        (e) => events.push(e)
       );
 
       // Code that creates a file with bash, then reads it with file_read
@@ -252,7 +262,10 @@ describe("code_execution integration tests", () => {
       const fileReadTool = createFileReadTool(toolConfig);
       const tools: Record<string, Tool> = { file_read: fileReadTool };
 
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools);
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools)
+      );
 
       // Call file_read without required filePath argument
       const code = `
@@ -284,8 +297,10 @@ describe("code_execution integration tests", () => {
       const tools: Record<string, Tool> = { throwing_tool: throwingTool };
 
       const events: PTCEvent[] = [];
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools, (e) =>
-        events.push(e)
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools),
+        (e) => events.push(e)
       );
 
       const code = `
@@ -318,8 +333,10 @@ describe("code_execution integration tests", () => {
       const tools: Record<string, Tool> = { file_read: fileReadTool };
 
       const events: PTCEvent[] = [];
-      const codeExecutionTool = await createCodeExecutionTool(runtimeFactory, tools, (e) =>
-        events.push(e)
+      const codeExecutionTool = await createCodeExecutionTool(
+        runtimeFactory,
+        new ToolBridge(tools),
+        (e) => events.push(e)
       );
 
       const code = `