@nitrostack/core 1.0.17 → 1.1.0-beta.1

package/dist/core/transforms/code-mode/synthetic-tools.js

@@ -0,0 +1,112 @@
+import { Tool } from '../../tool.js';
+import { clampSearchLimit } from '../search/synthetic-tools.js';
+/**
+ * Builds the 3 synthetic meta-tools (search, get_schema, execute) for Code Mode.
+ */
+export function buildCodeModeTools(bm25Engine, rawTools, workerPool, limits, customNames = {}, filterAuthorized = async (names) => names.map((n) => rawTools.get(n)).filter((t) => t !== undefined)) {
+    const searchName = customNames.searchToolName || 'search';
+    const getSchemaName = customNames.getSchemaToolName || 'get_schema';
+    const executeName = customNames.executeToolName || 'execute';
+    // 1. search meta-tool
+    const searchTool = new Tool({
+        name: searchName,
+        description: 'Searches available tools using natural language query or keywords. Returns tool names and brief summaries.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Natural language search query or keywords' },
+                limit: { type: 'number', description: 'Maximum number of tools to return (default: 5)' },
+            },
+            required: ['query'],
+        },
+        handler: async (args, context) => {
+            const limit = clampSearchLimit(args.limit, 5);
+            // Rank the full index, then drop what this session may not see, so a page
+            // of hidden tools cannot shrink the requested limit.
+            const ranked = bm25Engine.search(args.query, Number.MAX_SAFE_INTEGER);
+            const authorized = await filterAuthorized(ranked.map((r) => r.item.name), context);
+            const text = authorized
+                .slice(0, limit)
+                .map((tool) => `- **${tool.name}**: ${tool.description || 'No description'}`)
+                .join('\n');
+            return { content: [{ type: 'text', text: text || 'No matching tools found.' }] };
+        },
+    });
+    // 2. get_schema meta-tool
+    const getSchemaTool = new Tool({
+        name: getSchemaName,
+        description: 'Returns parameter schemas, types, and required fields for specified tools, plus ES2020 scripting constraints.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of tool names to inspect',
+                },
+            },
+            required: ['tools'],
+        },
+        handler: async (args, context) => {
+            const toolNames = args.tools || [];
+            if (toolNames.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No tools specified. Pass an array of tool names to inspect.',
+                        },
+                    ],
+                };
+            }
+            // Schemas are as sensitive as the tools themselves, so unauthorized names are
+            // reported as not found rather than distinguished from nonexistent ones.
+            const authorized = await filterAuthorized(toolNames, context);
+            const byName = new Map(authorized.map((tool) => [tool.name, tool]));
+            const sections = [];
+            for (const name of toolNames) {
+                const tool = byName.get(name);
+                if (!tool) {
+                    sections.push(`### ${name}\n*Tool not found.*`);
+                    continue;
+                }
+                const mcpTool = await tool.toMcpTool();
+                sections.push(`### ${tool.name}\n${tool.description || ''}\n\`\`\`json\n${JSON.stringify(mcpTool.inputSchema, null, 2)}\n\`\`\``);
+            }
+            return { content: [{ type: 'text', text: sections.join('\n\n') }] };
+        },
+    });
+    // 3. execute meta-tool
+    const executeTool = new Tool({
+        name: executeName,
+        description: 'Executes a JavaScript (ES2020) script within an isolated QuickJS WebAssembly sandbox with async callTool() access.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'JavaScript (ES2020) script to execute. Use await callTool(name, args).',
+                },
+            },
+            required: ['code'],
+        },
+        handler: async (args, context) => {
+            const result = await workerPool.executeScript(args.code, limits, context);
+            if (!result.success) {
+                throw new Error(`Script execution failed: ${result.error}`);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: typeof result.value === 'string'
+                            ? result.value
+                            : JSON.stringify(result.value ?? null, null, 2),
+                    },
+                ],
+            };
+        },
+    });
+    return { searchTool, getSchemaTool, executeTool };
+}
+//# sourceMappingURL=synthetic-tools.js.map

package/dist/core/transforms/code-mode/synthetic-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthetic-tools.js","sourceRoot":"","sources":["../../../../src/core/transforms/code-mode/synthetic-tools.ts"],"names":[],"mappings":"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"}

package/dist/core/transforms/code-mode/types.d.ts

@@ -0,0 +1,32 @@
+export interface ExecutionLimits {
+    timeoutMs: number;
+    memoryLimitMb: number;
+    maxToolCalls: number;
+    allowDestructive: boolean;
+}
+export interface SandboxLogEntry {
+    level: 'log' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+}
+export interface SandboxExecutionResult {
+    success: boolean;
+    value?: unknown;
+    error?: string;
+    logs: SandboxLogEntry[];
+    toolCallCount: number;
+    durationMs: number;
+    memoryUsedMb: number;
+}
+export interface CodeModeTransformOptions {
+    workerPoolSize?: number;
+    memoryLimitMb?: number;
+    timeoutMs?: number;
+    maxToolCalls?: number;
+    allowDestructive?: boolean;
+    alwaysVisible?: string[];
+    searchToolName?: string;
+    getSchemaToolName?: string;
+    executeToolName?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/transforms/code-mode/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/core/transforms/code-mode/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/core/transforms/code-mode/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/transforms/code-mode/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/core/transforms/code-mode/types.ts"],"names":[],"mappings":""}

package/dist/core/transforms/code-mode/worker-pool.d.ts

@@ -0,0 +1,71 @@
+import { Tool } from '../../tool.js';
+import { ExecutionContext } from '../../types.js';
+import { ExecutionLimits, SandboxExecutionResult } from './types.js';
+/**
+ * Resolves a tool name for a guest `callTool`. Implementations must walk the full
+ * transform chain so authorization transforms (e.g. session visibility) still apply
+ * to tools invoked from inside the sandbox.
+ */
+export type SandboxToolResolver = (name: string, context?: ExecutionContext) => Promise<Tool | undefined>;
+export declare class WorkerPool {
+    private readonly poolSize;
+    private readonly toolResolver;
+    /** Respawn attempts tolerated before the pool disables itself. */
+    private static readonly MAX_CONSECUTIVE_CRASHES;
+    /** Guest scripts longer than this are rejected before they reach a worker. */
+    private static readonly MAX_SCRIPT_CHARS;
+    private workers;
+    private idleWorkers;
+    private activeTasks;
+    private taskQueue;
+    /** Host-side tool calls still running for a sandbox task. Aborted when that task ends. */
+    private inflightCalls;
+    /** Calls whose guest is already gone; abort the handler without posting TOOL_RESPONSE. */
+    private silentCalls;
+    private isDisposed;
+    private consecutiveCrashes;
+    /** Set when the crash ceiling is breached; the pool stops respawning permanently. */
+    private disabledReason;
+    /** Workers stopped by the watchdog. Their exit is not a crash and must not respawn again. */
+    private readonly intentionalStop;
+    private readonly resolvedScriptPath;
+    private readonly memoryLimitMb;
+    constructor(poolSize: number | undefined, toolResolver: SandboxToolResolver, workerScriptPath?: string, memoryLimitMb?: number);
+    private resolveWorkerScriptPath;
+    /**
+     * Pre-spawns worker threads up to poolSize.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Submits a JavaScript script for sandboxed execution in an isolated worker thread.
+     */
+    executeScript(code: string, limits: ExecutionLimits, context?: ExecutionContext): Promise<SandboxExecutionResult>;
+    private spawnWorker;
+    private handleWorkerMessage;
+    private handleToolRequest;
+    private abortInflight;
+    private dispatchToolRequest;
+    /**
+     * A guest that exhausts the worker heap kills the thread. That is the memory
+     * limit working, not a broken pool: replace the worker once and do not count
+     * it toward the startup-failure latch.
+     */
+    private handleGuestMemoryLimit;
+    private handleWorkerCrash;
+    private removeWorker;
+    private dispatchNext;
+    /**
+     * Diagnostic pool statistics.
+     */
+    getStats(): {
+        totalWorkers: number;
+        idleWorkers: number;
+        activeTasks: number;
+        queuedTasks: number;
+    };
+    /**
+     * Gracefully drains task queue and terminates all worker threads.
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=worker-pool.d.ts.map

package/dist/core/transforms/code-mode/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../../src/core/transforms/code-mode/worker-pool.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAyBrE;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,gBAAgB,KACvB,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;AAE/B,qBAAa,UAAU;IAwBnB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAxB/B,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAK;IACpD,8EAA8E;IAC9E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAW;IAEnD,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,SAAS,CAAoB;IACrC,0FAA0F;IAC1F,OAAO,CAAC,aAAa,CAAwC;IAC7D,0FAA0F;IAC1F,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,kBAAkB,CAAK;IAC/B,qFAAqF;IACrF,OAAO,CAAC,cAAc,CAAsB;IAC5C,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IACzD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAGpB,QAAQ,EAAE,MAAM,YAAI,EACpB,YAAY,EAAE,mBAAmB,EAClD,gBAAgB,CAAC,EAAE,MAAM,EACzB,aAAa,GAAE,MAAY;IAM7B,OAAO,CAAC,uBAAuB;IAwC/B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC;;OAEG;IACG,aAAa,CACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,sBAAsB,CAAC;IAwBlC,OAAO,CAAC,WAAW;IAsDnB,OAAO,CAAC,mBAAmB;IAuC3B,OAAO,CAAC,iBAAiB;IAqBzB,OAAO,CAAC,aAAa;YASP,mBAAmB;IA8FjC;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAsB9B,OAAO,CAAC,iBAAiB;IAiCzB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,YAAY;IAuDpB;;OAEG;IACH,QAAQ;;;;;;IASR;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAgC/B"}

package/dist/core/transforms/code-mode/worker-pool.js

@@ -0,0 +1,435 @@
+import { Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+import { CatalogTransform } from '../catalog.transform.js';
+import { formatLegibleToolError } from './legible-error.js';
+import { assertToolAllowed } from './destructive-guard.js';
+import { validateToolArguments } from '../validate-tool-arguments.js';
+export class WorkerPool {
+    poolSize;
+    toolResolver;
+    /** Respawn attempts tolerated before the pool disables itself. */
+    static MAX_CONSECUTIVE_CRASHES = 5;
+    /** Guest scripts longer than this are rejected before they reach a worker. */
+    static MAX_SCRIPT_CHARS = 100_000;
+    workers = [];
+    idleWorkers = [];
+    activeTasks = new Map();
+    taskQueue = [];
+    /** Host-side tool calls still running for a sandbox task. Aborted when that task ends. */
+    inflightCalls = new Map();
+    /** Calls whose guest is already gone; abort the handler without posting TOOL_RESPONSE. */
+    silentCalls = new Set();
+    isDisposed = false;
+    consecutiveCrashes = 0;
+    /** Set when the crash ceiling is breached; the pool stops respawning permanently. */
+    disabledReason = null;
+    /** Workers stopped by the watchdog. Their exit is not a crash and must not respawn again. */
+    intentionalStop = new WeakSet();
+    resolvedScriptPath;
+    memoryLimitMb;
+    constructor(poolSize = 4, toolResolver, workerScriptPath, memoryLimitMb = 100) {
+        this.poolSize = poolSize;
+        this.toolResolver = toolResolver;
+        this.memoryLimitMb = memoryLimitMb;
+        this.resolvedScriptPath = this.resolveWorkerScriptPath(workerScriptPath);
+    }
+    resolveWorkerScriptPath(customPath) {
+        if (customPath && fs.existsSync(customPath)) {
+            return customPath;
+        }
+        // 1. Check relative to compiled module (e.g. dist/core/transforms/code-mode/sandbox.worker.js)
+        try {
+            const currentDir = path.dirname(fileURLToPath(import.meta.url));
+            const localJs = path.join(currentDir, 'sandbox.worker.js');
+            if (fs.existsSync(localJs)) {
+                return localJs;
+            }
+        }
+        catch {
+            // ignore import.meta.url failure in some bundlers
+        }
+        // 2. Check process.cwd() dist path
+        const cwdDist = path.resolve(process.cwd(), 'dist/core/transforms/code-mode/sandbox.worker.js');
+        if (fs.existsSync(cwdDist)) {
+            return cwdDist;
+        }
+        // 3. Fallback to package root dist path
+        const packageDist = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../dist/core/transforms/code-mode/sandbox.worker.js');
+        if (fs.existsSync(packageDist)) {
+            return packageDist;
+        }
+        // Fail here rather than returning an unverified path: every spawn would fail
+        // asynchronously, and each failure triggers a replacement spawn.
+        throw new Error(`Code Mode sandbox worker script not found (looked for sandbox.worker.js next to the ` +
+            `compiled module, under ${process.cwd()}/dist, and at ${packageDist}). ` +
+            `Build @nitrostack/core or pass an explicit workerScriptPath.`);
+    }
+    /**
+     * Pre-spawns worker threads up to poolSize.
+     */
+    async initialize() {
+        while (this.workers.length < this.poolSize) {
+            this.spawnWorker();
+        }
+    }
+    /**
+     * Submits a JavaScript script for sandboxed execution in an isolated worker thread.
+     */
+    async executeScript(code, limits, context) {
+        if (this.isDisposed) {
+            throw new Error('WorkerPool is already disposed');
+        }
+        if (this.disabledReason) {
+            throw this.disabledReason;
+        }
+        if (code.length > WorkerPool.MAX_SCRIPT_CHARS) {
+            throw new Error(`Script exceeds the maximum length of ${WorkerPool.MAX_SCRIPT_CHARS} characters`);
+        }
+        const queueCap = Math.max(this.poolSize, 1) * 8;
+        if (this.taskQueue.length >= queueCap) {
+            throw new Error('Code Mode sandbox queue is full');
+        }
+        return new Promise((resolve, reject) => {
+            const taskId = crypto.randomUUID();
+            this.taskQueue.push({ taskId, code, limits, context, resolve, reject });
+            this.dispatchNext();
+        });
+    }
+    spawnWorker() {
+        const execArgv = process.execArgv.filter((arg, i, arr) => arg !== '-e' &&
+            arg !== '--eval' &&
+            arg !== '-p' &&
+            arg !== '--print' &&
+            arr[i - 1] !== '-e' &&
+            arr[i - 1] !== '--eval' &&
+            arr[i - 1] !== '-p' &&
+            arr[i - 1] !== '--print');
+        const worker = new Worker(this.resolvedScriptPath, {
+            execArgv,
+            resourceLimits: {
+                maxOldGenerationSizeMb: this.memoryLimitMb,
+            },
+        });
+        this.workers.push(worker);
+        this.idleWorkers.push(worker);
+        worker.on('message', (msg) => {
+            this.handleWorkerMessage(worker, msg);
+        });
+        // A failing worker emits both 'error' and 'exit'. Without this latch each crash
+        // would be handled twice and spawn two replacements, growing the pool unbounded.
+        let crashHandled = false;
+        const onCrash = (err) => {
+            if (crashHandled)
+                return;
+            crashHandled = true;
+            this.handleWorkerCrash(worker, err);
+        };
+        worker.on('error', (err) => {
+            if (err?.code === 'ERR_WORKER_OUT_OF_MEMORY') {
+                this.handleGuestMemoryLimit(worker);
+                return;
+            }
+            onCrash(err);
+        });
+        worker.on('exit', (code) => {
+            if (this.intentionalStop.delete(worker))
+                return;
+            if (!this.isDisposed) {
+                onCrash(new Error(`Worker stopped with exit code ${code}`));
+            }
+        });
+        return worker;
+    }
+    handleWorkerMessage(worker, msg) {
+        const active = this.activeTasks.get(worker);
+        if (!active)
+            return;
+        // A late message from the previous script must not run against the next task.
+        if (msg.taskId !== active.task.taskId)
+            return;
+        if (msg.type === 'TOOL_REQUEST') {
+            this.handleToolRequest(worker, msg, active.task.limits, active.task.context);
+            return;
+        }
+        if (msg.type === 'EXECUTION_COMPLETE') {
+            clearTimeout(active.watchdogTimer);
+            this.abortInflight(active.task.taskId);
+            this.activeTasks.delete(worker);
+            this.idleWorkers.push(worker);
+            this.consecutiveCrashes = 0;
+            active.task.resolve(msg.result);
+            this.dispatchNext();
+            return;
+        }
+        if (msg.type === 'EXECUTION_FAILED') {
+            clearTimeout(active.watchdogTimer);
+            this.abortInflight(active.task.taskId);
+            this.activeTasks.delete(worker);
+            this.idleWorkers.push(worker);
+            active.task.resolve({
+                success: false,
+                error: msg.error,
+                logs: [],
+                toolCallCount: 0,
+                durationMs: 0,
+                memoryUsedMb: 0,
+            });
+            this.dispatchNext();
+        }
+    }
+    handleToolRequest(worker, msg, limits, context) {
+        const respond = (payload) => {
+            if (this.silentCalls.delete(msg.callId))
+                return;
+            worker.postMessage({
+                type: 'TOOL_RESPONSE',
+                taskId: msg.taskId,
+                callId: msg.callId,
+                ...payload,
+            });
+        };
+        void this.dispatchToolRequest(msg, limits, context).then(respond, (err) => respond({ error: err instanceof Error ? err.message : String(err) }));
+    }
+    abortInflight(taskId) {
+        for (const [callId, inflight] of this.inflightCalls) {
+            if (inflight.taskId !== taskId)
+                continue;
+            this.inflightCalls.delete(callId);
+            this.silentCalls.add(callId);
+            inflight.controller.abort();
+        }
+    }
+    async dispatchToolRequest(msg, limits, context) {
+        // Register before any await so a timeout during resolution still aborts the call.
+        const controller = new AbortController();
+        this.inflightCalls.set(msg.callId, { taskId: msg.taskId, controller });
+        const interrupted = 'callTool interrupted: script execution ended';
+        const stop = (payload) => {
+            this.inflightCalls.delete(msg.callId);
+            return payload;
+        };
+        if (controller.signal.aborted || this.silentCalls.has(msg.callId)) {
+            return stop({ error: interrupted });
+        }
+        // Resolution runs OUTSIDE withBypass so authorization transforms (session
+        // visibility) still gate tools reached from inside the sandbox. A guest script
+        // must not be able to call what its session is not allowed to call.
+        let tool;
+        try {
+            tool = await this.toolResolver(msg.toolName, context);
+        }
+        catch (err) {
+            // A transform denied resolution (e.g. VisibilityResolutionError). Surface it to
+            // the guest as a rejected callTool rather than failing the whole script.
+            return stop({ error: err instanceof Error ? err.message : String(err) });
+        }
+        if (controller.signal.aborted || this.silentCalls.has(msg.callId)) {
+            return stop({ error: interrupted });
+        }
+        if (!tool) {
+            return stop({
+                error: `Tool '${msg.toolName}' not found. Use search to discover valid tools.`,
+            });
+        }
+        let parsedArgs = {};
+        try {
+            assertToolAllowed(tool, limits.allowDestructive);
+            parsedArgs = validateToolArguments(tool, msg.args ?? {});
+        }
+        catch (err) {
+            return stop({ error: err instanceof Error ? err.message : String(err) });
+        }
+        if (controller.signal.aborted || this.silentCalls.has(msg.callId)) {
+            return stop({ error: interrupted });
+        }
+        const signals = [controller.signal];
+        if (context?.abortSignal)
+            signals.push(context.abortSignal);
+        const abortSignal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+        const execContext = {
+            ...(context ?? { metadata: {} }),
+            abortSignal,
+        };
+        return new Promise((resolve) => {
+            let finished = false;
+            const finish = (payload) => {
+                if (finished)
+                    return;
+                finished = true;
+                this.inflightCalls.delete(msg.callId);
+                resolve(payload);
+            };
+            if (abortSignal.aborted) {
+                finish({ error: interrupted });
+                return;
+            }
+            abortSignal.addEventListener('abort', () => finish({ error: interrupted }), { once: true });
+            void (async () => {
+                try {
+                    // withBypass covers catalog listing inside the handler so it does not
+                    // re-enter the pipeline. Authorization transforms still run: they do not
+                    // treat the bypass flag as permission to skip resolveTool.
+                    const result = await CatalogTransform.withBypass(() => tool.execute(parsedArgs, execContext));
+                    if (abortSignal.aborted) {
+                        finish({ error: interrupted });
+                        return;
+                    }
+                    finish({ result });
+                }
+                catch (err) {
+                    finish({ error: await formatLegibleToolError(tool, err) });
+                }
+            })();
+        });
+    }
+    /**
+     * A guest that exhausts the worker heap kills the thread. That is the memory
+     * limit working, not a broken pool: replace the worker once and do not count
+     * it toward the startup-failure latch.
+     */
+    handleGuestMemoryLimit(worker) {
+        if (this.intentionalStop.has(worker))
+            return;
+        this.intentionalStop.add(worker);
+        const active = this.activeTasks.get(worker);
+        if (active) {
+            clearTimeout(active.watchdogTimer);
+            this.abortInflight(active.task.taskId);
+            this.activeTasks.delete(worker);
+            active.task.reject(new Error(`Script exceeded the sandbox memory limit of ${this.memoryLimitMb}MB`));
+        }
+        this.removeWorker(worker);
+        void worker.terminate().catch(() => undefined);
+        if (this.isDisposed || this.disabledReason)
+            return;
+        this.spawnWorker();
+        this.dispatchNext();
+    }
+    handleWorkerCrash(worker, err) {
+        const active = this.activeTasks.get(worker);
+        if (active) {
+            clearTimeout(active.watchdogTimer);
+            this.abortInflight(active.task.taskId);
+            this.activeTasks.delete(worker);
+            active.task.reject(err);
+        }
+        this.removeWorker(worker);
+        if (this.isDisposed || this.disabledReason) {
+            return;
+        }
+        // A worker that cannot start (bad script path, unsupported runtime) crashes on
+        // every respawn. Give up rather than spin.
+        if (++this.consecutiveCrashes > WorkerPool.MAX_CONSECUTIVE_CRASHES) {
+            this.disabledReason = new Error(`Code Mode sandbox disabled after ${WorkerPool.MAX_CONSECUTIVE_CRASHES} consecutive ` +
+                `worker failures. Last error: ${err.message}`);
+            for (const task of this.taskQueue) {
+                task.reject(this.disabledReason);
+            }
+            this.taskQueue = [];
+            return;
+        }
+        this.spawnWorker();
+        this.dispatchNext();
+    }
+    removeWorker(worker) {
+        const idx = this.workers.indexOf(worker);
+        if (idx !== -1) {
+            this.workers.splice(idx, 1);
+        }
+        const idleIdx = this.idleWorkers.indexOf(worker);
+        if (idleIdx !== -1) {
+            this.idleWorkers.splice(idleIdx, 1);
+        }
+    }
+    dispatchNext() {
+        if (this.isDisposed || this.taskQueue.length === 0) {
+            return;
+        }
+        // If no idle worker available, check if we can spawn up to poolSize
+        if (this.idleWorkers.length === 0) {
+            if (this.workers.length < this.poolSize) {
+                this.spawnWorker();
+            }
+            else {
+                return; // All workers are busy; wait for a task to finish
+            }
+        }
+        const worker = this.idleWorkers.shift();
+        const task = this.taskQueue.shift();
+        if (!worker || !task) {
+            return;
+        }
+        // Tier 2 Timeout Watchdog: host deadline is limits.timeoutMs + 2000
+        const watchdogTimeoutMs = task.limits.timeoutMs + 2000;
+        const watchdogTimer = setTimeout(async () => {
+            this.intentionalStop.add(worker);
+            this.abortInflight(task.taskId);
+            this.activeTasks.delete(worker);
+            this.removeWorker(worker);
+            try {
+                await worker.terminate();
+            }
+            catch {
+                // Ignore termination failure
+            }
+            task.reject(new Error('Worker timed out and was terminated (Watchdog deadline exceeded)'));
+            if (!this.isDisposed) {
+                this.spawnWorker();
+                this.dispatchNext();
+            }
+        }, watchdogTimeoutMs);
+        this.activeTasks.set(worker, { task, watchdogTimer });
+        worker.postMessage({
+            type: 'EXECUTE',
+            taskId: task.taskId,
+            code: task.code,
+            limits: task.limits,
+        });
+    }
+    /**
+     * Diagnostic pool statistics.
+     */
+    getStats() {
+        return {
+            totalWorkers: this.workers.length,
+            idleWorkers: this.idleWorkers.length,
+            activeTasks: this.activeTasks.size,
+            queuedTasks: this.taskQueue.length,
+        };
+    }
+    /**
+     * Gracefully drains task queue and terminates all worker threads.
+     */
+    async dispose() {
+        this.isDisposed = true;
+        for (const task of this.taskQueue) {
+            task.reject(new Error('WorkerPool disposed'));
+        }
+        this.taskQueue = [];
+        for (const active of this.activeTasks.values()) {
+            clearTimeout(active.watchdogTimer);
+            this.abortInflight(active.task.taskId);
+            active.task.reject(new Error('WorkerPool disposed'));
+        }
+        for (const inflight of this.inflightCalls.values()) {
+            inflight.controller.abort();
+        }
+        this.inflightCalls.clear();
+        this.activeTasks.clear();
+        const terminations = this.workers.map(async (w) => {
+            try {
+                w.postMessage({ type: 'SHUTDOWN' });
+                await w.terminate();
+            }
+            catch {
+                // Ignore termination errors during disposal
+            }
+        });
+        this.workers = [];
+        this.idleWorkers = [];
+        await Promise.all(terminations);
+    }
+}
+//# sourceMappingURL=worker-pool.js.map