@ai-sdk/code-mode 0.0.0-2d998b35-20260731001744

package/src/utils/options.ts

@@ -0,0 +1,83 @@
+import type { CodeModeOptions, NormalizedCodeModeOptions } from '../types.js';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const DEFAULT_STACK_LIMIT_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_RESULT_BYTES = 1024 * 1024;
+const DEFAULT_MAX_CONSOLE_OUTPUT_BYTES = 64 * 1024;
+const DEFAULT_MAX_SOURCE_BYTES = 256 * 1024;
+const DEFAULT_MAX_TOOL_INPUT_BYTES = 1024 * 1024;
+const DEFAULT_MAX_TOOL_OUTPUT_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_BRIDGE_REQUESTS = 256;
+const DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS = 32;
+
+export function normalizeOptions(
+  options: CodeModeOptions = {},
+): NormalizedCodeModeOptions {
+  const executionPolicy = options.executionPolicy ?? {};
+
+  return {
+    timeoutMs: positiveInteger(
+      executionPolicy.timeoutMs,
+      DEFAULT_TIMEOUT_MS,
+      'executionPolicy.timeoutMs',
+    ),
+    memoryLimitBytes: positiveInteger(
+      executionPolicy.memoryLimitBytes,
+      DEFAULT_MEMORY_LIMIT_BYTES,
+      'executionPolicy.memoryLimitBytes',
+    ),
+    maxStackSizeBytes: positiveInteger(
+      executionPolicy.maxStackSizeBytes,
+      DEFAULT_STACK_LIMIT_BYTES,
+      'executionPolicy.maxStackSizeBytes',
+    ),
+    maxResultBytes: positiveInteger(
+      executionPolicy.maxResultBytes,
+      DEFAULT_MAX_RESULT_BYTES,
+      'executionPolicy.maxResultBytes',
+    ),
+    maxConsoleOutputBytes: positiveInteger(
+      executionPolicy.maxConsoleOutputBytes,
+      DEFAULT_MAX_CONSOLE_OUTPUT_BYTES,
+      'executionPolicy.maxConsoleOutputBytes',
+    ),
+    maxSourceBytes: positiveInteger(
+      executionPolicy.maxSourceBytes,
+      DEFAULT_MAX_SOURCE_BYTES,
+      'executionPolicy.maxSourceBytes',
+    ),
+    maxToolInputBytes: positiveInteger(
+      executionPolicy.maxToolInputBytes,
+      DEFAULT_MAX_TOOL_INPUT_BYTES,
+      'executionPolicy.maxToolInputBytes',
+    ),
+    maxToolOutputBytes: positiveInteger(
+      executionPolicy.maxToolOutputBytes,
+      DEFAULT_MAX_TOOL_OUTPUT_BYTES,
+      'executionPolicy.maxToolOutputBytes',
+    ),
+    maxBridgeRequests: positiveInteger(
+      executionPolicy.maxBridgeRequests,
+      DEFAULT_MAX_BRIDGE_REQUESTS,
+      'executionPolicy.maxBridgeRequests',
+    ),
+    maxInFlightBridgeRequests: positiveInteger(
+      executionPolicy.maxInFlightBridgeRequests,
+      DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS,
+      'executionPolicy.maxInFlightBridgeRequests',
+    ),
+  };
+}
+
+function positiveInteger(
+  value: number | undefined,
+  fallback: number,
+  path: string,
+): number {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved <= 0) {
+    throw new TypeError(`${path} must be a positive integer.`);
+  }
+  return resolved;
+}

package/src/utils/serialization.ts

@@ -0,0 +1,66 @@
+import { CodeModeError } from '../errors.js';
+
+export function assertJsonSerializable(
+  value: unknown,
+  maxBytes: number,
+  label: string,
+): void {
+  void toJsonPayload(value, maxBytes, label);
+}
+
+export function toJsonPayload(
+  value: unknown,
+  maxBytes: number,
+  label: string,
+): string {
+  if (value === undefined) {
+    return '';
+  }
+
+  return toStrictJsonPayload(value, maxBytes, label);
+}
+
+export function toStrictJsonPayload(
+  value: unknown,
+  maxBytes: number,
+  label: string,
+): string {
+  let encoded: string | undefined;
+  try {
+    encoded = JSON.stringify(value);
+  } catch (error) {
+    throw new CodeModeError(
+      `${label} is not JSON-serializable: ${getErrorMessage(error)}`,
+      'CODE_MODE_SERIALIZATION_ERROR',
+    );
+  }
+
+  if (encoded === undefined) {
+    throw new CodeModeError(
+      `${label} is not JSON-serializable.`,
+      'CODE_MODE_SERIALIZATION_ERROR',
+    );
+  }
+
+  assertJsonPayloadSize(encoded, maxBytes, label);
+  return encoded;
+}
+
+export function assertJsonPayloadSize(
+  valueJson: string,
+  maxBytes: number,
+  label: string,
+): void {
+  const bytes = new TextEncoder().encode(valueJson).byteLength;
+  if (bytes > maxBytes) {
+    throw new CodeModeError(
+      `${label} exceeds the ${maxBytes} byte size limit.`,
+      'CODE_MODE_SERIALIZATION_ERROR',
+      { bytes, maxBytes },
+    );
+  }
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/utils/source-cache.ts

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { stripTypeScriptTypes } from 'node:module';
+import { CodeModeSourceTooLargeError } from '../errors.js';
+
+const MAX_CACHE_ENTRIES = 256;
+const MAX_CACHE_BYTES = 4 * 1024 * 1024;
+const MAX_CACHE_ENTRY_BYTES = 64 * 1024;
+const transformedSourceCache = new Map<
+  string,
+  {
+    source: string;
+    bytes: number;
+  }
+>();
+let transformedSourceCacheBytes = 0;
+
+export function assertSourceSize(source: string, maxSourceBytes: number): void {
+  const bytes = byteLength(source);
+  if (bytes > maxSourceBytes) {
+    throw new CodeModeSourceTooLargeError(bytes, maxSourceBytes);
+  }
+}
+
+export function transformSource(source: string): string {
+  const hash = createHash('sha256')
+    .update('strip:')
+    .update(source)
+    .digest('hex');
+  const cached = transformedSourceCache.get(hash);
+  if (cached !== undefined) {
+    transformedSourceCache.delete(hash);
+    transformedSourceCache.set(hash, cached);
+    return cached.source;
+  }
+
+  const transformed = stripSnippetTypes(source);
+  const transformedBytes = byteLength(transformed);
+  if (transformedBytes <= MAX_CACHE_ENTRY_BYTES) {
+    transformedSourceCache.set(hash, {
+      source: transformed,
+      bytes: transformedBytes,
+    });
+    transformedSourceCacheBytes += transformedBytes;
+    evictTransformedSourceCache();
+  }
+  return transformed;
+}
+
+export function getTransformedSourceCacheStats() {
+  return {
+    entries: transformedSourceCache.size,
+    bytes: transformedSourceCacheBytes,
+    maxEntries: MAX_CACHE_ENTRIES,
+    maxBytes: MAX_CACHE_BYTES,
+    maxEntryBytes: MAX_CACHE_ENTRY_BYTES,
+  };
+}
+
+export function clearTransformedSourceCache(): void {
+  transformedSourceCache.clear();
+  transformedSourceCacheBytes = 0;
+}
+
+function stripSnippetTypes(source: string): string {
+  const prefix = 'async function __codeModeUser__(){\n';
+  const suffix = '\n}';
+  const stripped = stripTypeScriptTypes(`${prefix}${source}${suffix}`);
+  if (!stripped.startsWith(prefix) || !stripped.endsWith(suffix)) {
+    return source;
+  }
+  return stripped.slice(prefix.length, -suffix.length);
+}
+
+function evictTransformedSourceCache(): void {
+  while (
+    transformedSourceCache.size > MAX_CACHE_ENTRIES ||
+    transformedSourceCacheBytes > MAX_CACHE_BYTES
+  ) {
+    const oldest = transformedSourceCache.keys().next().value;
+    if (oldest === undefined) {
+      return;
+    }
+    const entry = transformedSourceCache.get(oldest);
+    transformedSourceCache.delete(oldest);
+    transformedSourceCacheBytes -= entry?.bytes ?? 0;
+  }
+}
+
+function byteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}