tywrap 0.8.0 → 0.10.0

package/src/runtime/node.ts

@@ -16,7 +16,6 @@ import { createRequire } from 'node:module';
 import { autoRegisterArrowDecoder } from '../utils/codec.js';
 import { getDefaultPythonPath } from '../utils/python.js';
 import { getVenvBinDir, getVenvPythonExe } from '../utils/runtime.js';
-import { globalCache } from '../utils/cache.js';
 
 import { BasePythonBridge } from './base-bridge.js';
 import { RpcClient } from './rpc-client.js';
@@ -24,7 +23,7 @@ import { BridgeCodecError, BridgeExecutionError, BridgeProtocolError } from './e
 import { SubprocessTransport } from './subprocess-transport.js';
 import { PooledTransport } from './pooled-transport.js';
 import type { CodecOptions } from './bridge-codec.js';
-import type { TransportLease } from './transport-pool.js';
+import type { TransportLease } from './pooled-transport.js';
 
 // =============================================================================
 // OPTIONS
@@ -40,7 +39,12 @@ export interface NodeBridgeOptions {
   /** Maximum number of Python processes to spawn. Default: 1 (single-process mode) */
   maxProcesses?: number;
 
-  /** Maximum concurrent requests per process. Default: 10 */
+  /**
+   * Maximum concurrent requests per process. Default: 1.
+   *
+   * Python bridge workers process JSONL requests serially, so the default lets
+   * the pool use another process for concurrent calls when one is available.
+   */
   maxConcurrentPerProcess?: number;
 
   /** Path to Python executable. Auto-detected if not specified. */
@@ -64,29 +68,12 @@ export interface NodeBridgeOptions {
   /** Inherit all environment variables from parent process. Default: false */
   inheritProcessEnv?: boolean;
 
-  /** Enable result caching for pure functions. Default: false */
-  enableCache?: boolean;
-
   /** Optional extra environment variables to pass to the Python subprocess. */
   env?: Record<string, string | undefined>;
 
   /** Codec options for validation/serialization */
   codec?: CodecOptions;
 
-  /**
-   * Negotiate the chunked transport (`tywrap-frame/1`) so a large result that
-   * would exceed a single JSONL line is split into frames and transparently
-   * reassembled. Default: `true`.
-   *
-   * Negotiation degrades safely: small payloads are unaffected, and a bridge
-   * that does not advertise chunking still fails loud on an oversize payload
-   * (never a silent single-frame fallback). Chunking only engages above the
-   * frame ceiling, so raising the codec payload cap (`codec`) is what unlocks
-   * genuinely large results — flipping this alone changes nothing for typical
-   * small-payload traffic.
-   */
-  enableChunking?: boolean;
-
   /** Commands to run on each process at startup for warming up. */
   warmupCommands?: Array<
     { module: string; functionName: string; args?: unknown[] } | { method: string; params: unknown } // Legacy shape preserved so runtime can surface a migration error
@@ -132,8 +119,6 @@ interface ResolvedOptions {
   timeoutMs: number;
   queueTimeoutMs: number;
   inheritProcessEnv: boolean;
-  enableCache: boolean;
-  enableChunking: boolean;
   env: Record<string, string | undefined>;
   codec?: CodecOptions;
   warmupCommands: WarmupCommand[];
@@ -293,7 +278,6 @@ function normalizeWarmupCommands(commands: NodeBridgeOptions['warmupCommands']):
  * - Virtual environment support
  * - Full BridgeCodec validation (NaN/Infinity rejection, key validation)
  * - Automatic Arrow decoding for DataFrames/ndarrays
- * - Optional result caching for pure functions
  * - Process warmup commands
  *
  * @example
@@ -314,7 +298,6 @@ function normalizeWarmupCommands(commands: NodeBridgeOptions['warmupCommands']):
  * const pooledBridge = new NodeBridge({
  *   maxProcesses: 4,
  *   maxConcurrentPerProcess: 2,
- *   enableCache: true,
  * });
  * await pooledBridge.init();
  * ```
@@ -344,7 +327,7 @@ export class NodeBridge extends BasePythonBridge {
     const resolvedOptions: ResolvedOptions = {
       minProcesses,
       maxProcesses,
-      maxConcurrentPerProcess: options.maxConcurrentPerProcess ?? 10,
+      maxConcurrentPerProcess: options.maxConcurrentPerProcess ?? 1,
       pythonPath: options.pythonPath ?? venv?.pythonPath ?? getDefaultPythonPath(),
       scriptPath: resolvedScriptPath,
       virtualEnv,
@@ -352,8 +335,6 @@ export class NodeBridge extends BasePythonBridge {
       timeoutMs: options.timeoutMs ?? 30000,
       queueTimeoutMs: options.queueTimeoutMs ?? 30000,
       inheritProcessEnv: options.inheritProcessEnv ?? false,
-      enableCache: options.enableCache ?? false,
-      enableChunking: options.enableChunking ?? true,
       env: options.env ?? {},
       codec: options.codec,
       warmupCommands,
@@ -383,7 +364,6 @@ export class NodeBridge extends BasePythonBridge {
           bridgeScript: resolvedOptions.scriptPath,
           env: processEnv,
           cwd: resolvedOptions.cwd,
-          enableChunking: resolvedOptions.enableChunking,
           // Bound chunked-response reassembly to the codec's logical payload cap
           // so a huge response fails loud early instead of buffering to OOM.
           maxReassemblyBytes: resolvedOptions.codec?.maxPayloadBytes,
@@ -457,57 +437,12 @@ export class NodeBridge extends BasePythonBridge {
 
   /**
    * Expose the held RpcClient to BasePythonBridge's shared delegating methods
-   * (instantiate/callMethod/disposeInstance/getBridgeInfo). call() is
-   * overridden below to layer caching on top.
+   * (call/getBridgeInfo).
    */
   protected getRpcClient(): RpcClient {
     return this.rpc;
   }
 
-  /**
-   * Call a Python function, with optional result caching.
-   *
-   * Overrides BasePythonBridge.call() to layer the cache lookup/writeback on
-   * top of the shared delegation. Cache lookup stays FIRST so cache hits return
-   * without forcing init, preserving the pre-composition behavior.
-   */
-  override async call<T = unknown>(
-    module: string,
-    functionName: string,
-    args: unknown[],
-    kwargs?: Record<string, unknown>
-  ): Promise<T> {
-    // Check cache if enabled
-    if (this.resolvedOptions.enableCache) {
-      const cacheKey = this.safeCacheKey('runtime_call', module, functionName, args, kwargs);
-      if (cacheKey) {
-        const cached = await globalCache.get<T>(cacheKey);
-        if (cached !== null) {
-          return cached;
-        }
-      }
-
-      // Execute and cache if pure function
-      const startTime = performance.now();
-      await this.ensureReady();
-      const result = await this.rpc.call<T>(module, functionName, args, kwargs);
-      const duration = performance.now() - startTime;
-
-      if (cacheKey && this.isPureFunctionCandidate(functionName, args)) {
-        await globalCache.set(cacheKey, result, {
-          computeTime: duration,
-          dependencies: [module],
-        });
-      }
-
-      return result;
-    }
-
-    // No caching - direct call
-    await this.ensureReady();
-    return this.rpc.call<T>(module, functionName, args, kwargs);
-  }
-
   // ===========================================================================
   // POOL STATISTICS
   // ===========================================================================
@@ -561,52 +496,6 @@ export class NodeBridge extends BasePythonBridge {
       busyWorkers: poolStats.totalInFlight,
     };
   }
-
-  // ===========================================================================
-  // PRIVATE HELPERS
-  // ===========================================================================
-
-  /**
-   * Generate a cache key, returning null if generation fails.
-   */
-  private safeCacheKey(prefix: string, ...inputs: unknown[]): string | null {
-    try {
-      return globalCache.generateKey(prefix, ...inputs);
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Heuristic to determine if function result should be cached.
-   */
-  private isPureFunctionCandidate(functionName: string, args: unknown[]): boolean {
-    const pureFunctionPatterns = [
-      /^(get|fetch|read|load|find|search|query|select)_/i,
-      /^(compute|calculate|process|transform|convert)_/i,
-      /^(encode|decode|serialize|deserialize)_/i,
-    ];
-
-    const impureFunctionPatterns = [
-      /^(set|save|write|update|insert|delete|create|modify)_/i,
-      /^(send|post|put|patch)_/i,
-      /random|uuid|timestamp|now|current/i,
-    ];
-
-    if (impureFunctionPatterns.some(pattern => pattern.test(functionName))) {
-      return false;
-    }
-
-    if (pureFunctionPatterns.some(pattern => pattern.test(functionName))) {
-      return true;
-    }
-
-    const hasComplexArgs = args.some(
-      arg => arg !== null && typeof arg === 'object' && !(arg instanceof Date)
-    );
-
-    return !hasComplexArgs && args.length <= 3;
-  }
 }
 
 // =============================================================================