@librechat/agents 3.2.32 → 3.2.34

package/dist/cjs/tools/local/LocalProgrammaticToolCalling.cjs

@@ -1,294 +1,236 @@
-'use strict';
-
-var http = require('http');
-var tools = require('@langchain/core/tools');
-var crypto = require('crypto');
-var ProgrammaticToolCalling = require('../ProgrammaticToolCalling.cjs');
-var BashProgrammaticToolCalling = require('../BashProgrammaticToolCalling.cjs');
-var LocalExecutionEngine = require('./LocalExecutionEngine.cjs');
-var executeHooks = require('../../hooks/executeHooks.cjs');
-require('../../hooks/createWorkspacePolicyHook.cjs');
-var _enum = require('../../common/enum.cjs');
-
-const DEFAULT_TIMEOUT = 60000;
-const LOCAL_MIN_TIMEOUT = 1000;
-const LOCAL_MAX_TIMEOUT = 300000;
+require("../../common/enum.cjs");
+require("../../common/index.cjs");
+const require_LocalExecutionEngine = require("./LocalExecutionEngine.cjs");
+const require_ProgrammaticToolCalling = require("../ProgrammaticToolCalling.cjs");
+const require_BashProgrammaticToolCalling = require("../BashProgrammaticToolCalling.cjs");
+const require_executeHooks = require("../../hooks/executeHooks.cjs");
+require("../../hooks/index.cjs");
+let _langchain_core_tools = require("@langchain/core/tools");
+let crypto = require("crypto");
+let http = require("http");
+//#region src/tools/local/LocalProgrammaticToolCalling.ts
+const DEFAULT_TIMEOUT = 6e4;
+const LOCAL_MIN_TIMEOUT = 1e3;
+const LOCAL_MAX_TIMEOUT = 3e5;
 function normalizeLocalTimeout(timeoutMs) {
-    if (timeoutMs == null || !Number.isFinite(timeoutMs)) {
-        return DEFAULT_TIMEOUT;
-    }
-    return Math.max(LOCAL_MIN_TIMEOUT, Math.floor(timeoutMs));
+	if (timeoutMs == null || !Number.isFinite(timeoutMs)) return DEFAULT_TIMEOUT;
+	return Math.max(LOCAL_MIN_TIMEOUT, Math.floor(timeoutMs));
 }
 function formatLocalTimeout(timeoutMs) {
-    return timeoutMs % 1000 === 0
-        ? `${timeoutMs / 1000} seconds`
-        : `${timeoutMs} milliseconds`;
+	return timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3} seconds` : `${timeoutMs} milliseconds`;
 }
 function createLocalTimeoutSchema(timeoutMs) {
-    const defaultTimeout = normalizeLocalTimeout(timeoutMs);
-    const maxTimeout = Math.max(LOCAL_MAX_TIMEOUT, defaultTimeout);
-    const formattedDefault = formatLocalTimeout(defaultTimeout);
-    const formattedMax = formatLocalTimeout(maxTimeout);
-    return {
-        type: 'integer',
-        minimum: LOCAL_MIN_TIMEOUT,
-        maximum: maxTimeout,
-        default: defaultTimeout,
-        description: 'Maximum local execution time in milliseconds. ' +
-            `Default: ${formattedDefault}. Max: ${formattedMax}.`,
-    };
+	const defaultTimeout = normalizeLocalTimeout(timeoutMs);
+	const maxTimeout = Math.max(LOCAL_MAX_TIMEOUT, defaultTimeout);
+	return {
+		type: "integer",
+		minimum: LOCAL_MIN_TIMEOUT,
+		maximum: maxTimeout,
+		default: defaultTimeout,
+		description: `Maximum local execution time in milliseconds. Default: ${formatLocalTimeout(defaultTimeout)}. Max: ${formatLocalTimeout(maxTimeout)}.`
+	};
 }
 function createLocalProgrammaticToolCallingSchema(localConfig = {}) {
-    return {
-        ...ProgrammaticToolCalling.ProgrammaticToolCallingSchema,
-        properties: {
-            ...ProgrammaticToolCalling.ProgrammaticToolCallingSchema.properties,
-            timeout: createLocalTimeoutSchema(localConfig.timeoutMs),
-            lang: {
-                type: 'string',
-                enum: ['py', 'python', 'bash', 'sh'],
-                default: 'bash',
-                description: 'Local engine runtime for orchestration code. Defaults to bash; use py/python for Python orchestration.',
-            },
-        },
-    };
+	return {
+		...require_ProgrammaticToolCalling.ProgrammaticToolCallingSchema,
+		properties: {
+			...require_ProgrammaticToolCalling.ProgrammaticToolCallingSchema.properties,
+			timeout: createLocalTimeoutSchema(localConfig.timeoutMs),
+			lang: {
+				type: "string",
+				enum: [
+					"py",
+					"python",
+					"bash",
+					"sh"
+				],
+				default: "bash",
+				description: "Local engine runtime for orchestration code. Defaults to bash; use py/python for Python orchestration."
+			}
+		}
+	};
 }
 function createLocalBashProgrammaticToolCallingSchema(localConfig = {}) {
-    return {
-        ...BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema,
-        properties: {
-            ...BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema.properties,
-            timeout: createLocalTimeoutSchema(localConfig.timeoutMs),
-        },
-    };
+	return {
+		...require_BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema,
+		properties: {
+			...require_BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema.properties,
+			timeout: createLocalTimeoutSchema(localConfig.timeoutMs)
+		}
+	};
 }
-const BRIDGE_AUTH_HEADER = 'x-librechat-bridge-token';
+const BRIDGE_AUTH_HEADER = "x-librechat-bridge-token";
 function constantTimeEquals(a, b) {
-    const aBuf = Buffer.from(a, 'utf8');
-    const bBuf = Buffer.from(b, 'utf8');
-    if (aBuf.length !== bBuf.length) {
-        return false;
-    }
-    return crypto.timingSafeEqual(aBuf, bBuf);
+	const aBuf = Buffer.from(a, "utf8");
+	const bBuf = Buffer.from(b, "utf8");
+	if (aBuf.length !== bBuf.length) return false;
+	return (0, crypto.timingSafeEqual)(aBuf, bBuf);
 }
 function resolveRuntime(params) {
-    const rawRuntime = params.lang ?? params.runtime ?? params.language ?? 'bash';
-    return rawRuntime === 'py' || rawRuntime === 'python' ? 'python' : 'bash';
+	const rawRuntime = params.lang ?? params.runtime ?? params.language ?? "bash";
+	return rawRuntime === "py" || rawRuntime === "python" ? "python" : "bash";
 }
 function toSerializable(value) {
-    if (value === undefined) {
-        return null;
-    }
-    return value;
+	if (value === void 0) return null;
+	return value;
 }
 async function readRequestBody(req) {
-    const chunks = [];
-    for await (const chunk of req) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    const raw = Buffer.concat(chunks).toString('utf8');
-    if (raw === '') {
-        return {};
-    }
-    return JSON.parse(raw);
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const raw = Buffer.concat(chunks).toString("utf8");
+	if (raw === "") return {};
+	return JSON.parse(raw);
 }
 function writeJson(res, status, value) {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(value));
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(value));
 }
 /**
- * Run the host's `PreToolUse` hook chain for a single bridge call.
- * Returns the (possibly rewritten) input and a `denyReason` if any
- * matcher returned `decision: 'deny'` or `'ask'`. `'ask'` collapses
- * to deny because the bridge can't raise a LangGraph interrupt from
- * inside an HTTP handler — fail-closed matches the rest of the SDK
- * when HITL is unavailable.
- *
- * @internal Exported for tests so the deny / allow / updatedInput /
- *   ask branches can be exercised without standing up the full HTTP
- *   bridge.
- */
+* Run the host's `PreToolUse` hook chain for a single bridge call.
+* Returns the (possibly rewritten) input and a `denyReason` if any
+* matcher returned `decision: 'deny'` or `'ask'`. `'ask'` collapses
+* to deny because the bridge can't raise a LangGraph interrupt from
+* inside an HTTP handler — fail-closed matches the rest of the SDK
+* when HITL is unavailable.
+*
+* @internal Exported for tests so the deny / allow / updatedInput /
+*   ask branches can be exercised without standing up the full HTTP
+*   bridge.
+*/
 async function applyPreToolUseHooksForBridge(hookContext, toolName, toolUseId, toolInput) {
-    if (hookContext.registry == null) {
-        return { input: toolInput };
-    }
-    const result = await executeHooks.executeHooks({
-        registry: hookContext.registry,
-        input: {
-            hook_event_name: 'PreToolUse',
-            runId: hookContext.runId,
-            threadId: hookContext.threadId,
-            agentId: hookContext.agentId,
-            executingAgentId: hookContext.executingAgentId,
-            toolName,
-            toolInput,
-            toolUseId,
-            stepId: '',
-            turn: 0,
-        },
-        sessionId: hookContext.runId,
-        matchQuery: toolName,
-    }).catch(() => undefined);
-    if (result == null) {
-        return { input: toolInput };
-    }
-    const nextInput = result.updatedInput != null
-        ? result.updatedInput
-        : toolInput;
-    if (result.decision === 'deny' || result.decision === 'ask') {
-        return {
-            input: nextInput,
-            denyReason: result.reason ??
-                (result.decision === 'ask'
-                    ? `Tool "${toolName}" requires human approval; bridge cannot raise an interrupt — denying.`
-                    : `Tool "${toolName}" denied by PreToolUse hook.`),
-        };
-    }
-    return { input: nextInput };
+	if (hookContext.registry == null) return { input: toolInput };
+	const result = await require_executeHooks.executeHooks({
+		registry: hookContext.registry,
+		input: {
+			hook_event_name: "PreToolUse",
+			runId: hookContext.runId,
+			threadId: hookContext.threadId,
+			agentId: hookContext.agentId,
+			executingAgentId: hookContext.executingAgentId,
+			toolName,
+			toolInput,
+			toolUseId,
+			stepId: "",
+			turn: 0
+		},
+		sessionId: hookContext.runId,
+		matchQuery: toolName
+	}).catch(() => void 0);
+	if (result == null) return { input: toolInput };
+	const nextInput = result.updatedInput != null ? result.updatedInput : toolInput;
+	if (result.decision === "deny" || result.decision === "ask") return {
+		input: nextInput,
+		denyReason: result.reason ?? (result.decision === "ask" ? `Tool "${toolName}" requires human approval; bridge cannot raise an interrupt — denying.` : `Tool "${toolName}" denied by PreToolUse hook.`)
+	};
+	return { input: nextInput };
 }
 async function createToolBridge(toolMap, hookContext) {
-    const token = crypto.randomBytes(32).toString('hex');
-    const server = http.createServer((req, res) => {
-        // `?mode=text` returns the already-serialized result as the body
-        // (or the error message at non-2xx). Python/Node callers stay on
-        // JSON; bash callers using curl can avoid pulling in a JSON
-        // parser dependency (Codex P2 #19 — `python3` was a hard
-        // requirement for the bash bridge, breaking minimal containers).
-        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
-        const isTextMode = url.searchParams.get('mode') === 'text';
-        if (req.method !== 'POST' || url.pathname !== '/tool') {
-            if (isTextMode) {
-                res.writeHead(404, { 'Content-Type': 'text/plain' });
-                res.end('Not found');
-            }
-            else {
-                writeJson(res, 404, { error: 'Not found' });
-            }
-            return;
-        }
-        const presented = req.headers[BRIDGE_AUTH_HEADER];
-        const presentedToken = Array.isArray(presented) ? presented[0] : presented;
-        if (typeof presentedToken !== 'string' ||
-            !constantTimeEquals(presentedToken, token)) {
-            if (isTextMode) {
-                res.writeHead(401, { 'Content-Type': 'text/plain' });
-                res.end('Unauthorized');
-            }
-            else {
-                writeJson(res, 401, { error: 'Unauthorized' });
-            }
-            return;
-        }
-        readRequestBody(req)
-            .then(async (body) => {
-            if (typeof body.name !== 'string' || body.name === '') {
-                const message = 'Tool request is missing a tool name.';
-                if (isTextMode) {
-                    res.writeHead(400, { 'Content-Type': 'text/plain' });
-                    res.end(message);
-                }
-                else {
-                    writeJson(res, 400, {
-                        call_id: body.id ?? 'invalid',
-                        result: null,
-                        is_error: true,
-                        error_message: message,
-                    });
-                }
-                return;
-            }
-            const callId = body.id ?? `local_call_${crypto.randomUUID()}`;
-            let effectiveInput = body.input ?? {};
-            if (hookContext != null) {
-                const gate = await applyPreToolUseHooksForBridge(hookContext, body.name, callId, effectiveInput);
-                if (gate.denyReason != null) {
-                    const denyMsg = gate.denyReason;
-                    if (isTextMode) {
-                        res.writeHead(500, { 'Content-Type': 'text/plain' });
-                        res.end(denyMsg);
-                    }
-                    else {
-                        writeJson(res, 500, {
-                            call_id: callId,
-                            result: null,
-                            is_error: true,
-                            error_message: denyMsg,
-                        });
-                    }
-                    return;
-                }
-                effectiveInput = gate.input;
-            }
-            const [result] = await ProgrammaticToolCalling.executeTools([
-                {
-                    id: callId,
-                    name: body.name,
-                    input: effectiveInput,
-                },
-            ], toolMap);
-            if (isTextMode) {
-                if (result.is_error === true) {
-                    res.writeHead(500, { 'Content-Type': 'text/plain' });
-                    res.end(result.error_message ?? `Tool ${body.name} failed`);
-                }
-                else {
-                    const value = toSerializable(result.result);
-                    const text = typeof value === 'string' ? value : JSON.stringify(value);
-                    res.writeHead(200, { 'Content-Type': 'text/plain' });
-                    res.end(text);
-                }
-                return;
-            }
-            writeJson(res, 200, {
-                ...result,
-                result: toSerializable(result.result),
-            });
-        })
-            .catch((error) => {
-            if (isTextMode) {
-                res.writeHead(500, { 'Content-Type': 'text/plain' });
-                res.end(error.message);
-            }
-            else {
-                writeJson(res, 500, {
-                    call_id: 'error',
-                    result: null,
-                    is_error: true,
-                    error_message: error.message,
-                });
-            }
-        });
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', resolve);
-    });
-    const address = server.address();
-    return {
-        url: `http://127.0.0.1:${address.port}/tool`,
-        token,
-        close: () => new Promise((resolve, reject) => {
-            server.close((error) => (error ? reject(error) : resolve()));
-        }),
-    };
+	const token = (0, crypto.randomBytes)(32).toString("hex");
+	const server = (0, http.createServer)((req, res) => {
+		const url = new URL(req.url ?? "/", "http://127.0.0.1");
+		const isTextMode = url.searchParams.get("mode") === "text";
+		if (req.method !== "POST" || url.pathname !== "/tool") {
+			if (isTextMode) {
+				res.writeHead(404, { "Content-Type": "text/plain" });
+				res.end("Not found");
+			} else writeJson(res, 404, { error: "Not found" });
+			return;
+		}
+		const presented = req.headers[BRIDGE_AUTH_HEADER];
+		const presentedToken = Array.isArray(presented) ? presented[0] : presented;
+		if (typeof presentedToken !== "string" || !constantTimeEquals(presentedToken, token)) {
+			if (isTextMode) {
+				res.writeHead(401, { "Content-Type": "text/plain" });
+				res.end("Unauthorized");
+			} else writeJson(res, 401, { error: "Unauthorized" });
+			return;
+		}
+		readRequestBody(req).then(async (body) => {
+			if (typeof body.name !== "string" || body.name === "") {
+				const message = "Tool request is missing a tool name.";
+				if (isTextMode) {
+					res.writeHead(400, { "Content-Type": "text/plain" });
+					res.end(message);
+				} else writeJson(res, 400, {
+					call_id: body.id ?? "invalid",
+					result: null,
+					is_error: true,
+					error_message: message
+				});
+				return;
+			}
+			const callId = body.id ?? `local_call_${(0, crypto.randomUUID)()}`;
+			let effectiveInput = body.input ?? {};
+			if (hookContext != null) {
+				const gate = await applyPreToolUseHooksForBridge(hookContext, body.name, callId, effectiveInput);
+				if (gate.denyReason != null) {
+					const denyMsg = gate.denyReason;
+					if (isTextMode) {
+						res.writeHead(500, { "Content-Type": "text/plain" });
+						res.end(denyMsg);
+					} else writeJson(res, 500, {
+						call_id: callId,
+						result: null,
+						is_error: true,
+						error_message: denyMsg
+					});
+					return;
+				}
+				effectiveInput = gate.input;
+			}
+			const [result] = await require_ProgrammaticToolCalling.executeTools([{
+				id: callId,
+				name: body.name,
+				input: effectiveInput
+			}], toolMap);
+			if (isTextMode) {
+				if (result.is_error === true) {
+					res.writeHead(500, { "Content-Type": "text/plain" });
+					res.end(result.error_message ?? `Tool ${body.name} failed`);
+				} else {
+					const value = toSerializable(result.result);
+					const text = typeof value === "string" ? value : JSON.stringify(value);
+					res.writeHead(200, { "Content-Type": "text/plain" });
+					res.end(text);
+				}
+				return;
+			}
+			writeJson(res, 200, {
+				...result,
+				result: toSerializable(result.result)
+			});
+		}).catch((error) => {
+			if (isTextMode) {
+				res.writeHead(500, { "Content-Type": "text/plain" });
+				res.end(error.message);
+			} else writeJson(res, 500, {
+				call_id: "error",
+				result: null,
+				is_error: true,
+				error_message: error.message
+			});
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", resolve);
+	});
+	return {
+		url: `http://127.0.0.1:${server.address().port}/tool`,
+		token,
+		close: () => new Promise((resolve, reject) => {
+			server.close((error) => error ? reject(error) : resolve());
+		})
+	};
 }
 function indent(code) {
-    return code
-        .split('\n')
-        .map((line) => `  ${line}`)
-        .join('\n');
+	return code.split("\n").map((line) => `  ${line}`).join("\n");
 }
 function createPythonProgram(code, toolDefs, bridgeUrl, bridgeToken) {
-    const functionDefs = toolDefs
-        .map((def) => {
-        const pythonName = ProgrammaticToolCalling.normalizeToPythonIdentifier(def.name);
-        return [
-            `async def ${pythonName}(**kwargs):`,
-            `  return await __librechat_call_tool(${JSON.stringify(def.name)}, kwargs)`,
-        ].join('\n');
-    })
-        .join('\n\n');
-    return `
+	const functionDefs = toolDefs.map((def) => {
+		return [`async def ${require_ProgrammaticToolCalling.normalizeToPythonIdentifier(def.name)}(**kwargs):`, `  return await __librechat_call_tool(${JSON.stringify(def.name)}, kwargs)`].join("\n");
+	}).join("\n\n");
+	return `
 import asyncio
 import json
 import urllib.request
@@ -323,25 +265,22 @@ asyncio.run(__librechat_main())
 `.trimStart();
 }
 function _createBashProgramForTests(code, toolDefs, bridgeUrl, bridgeToken) {
-    return createBashProgram(code, toolDefs, bridgeUrl, bridgeToken);
+	return createBashProgram(code, toolDefs, bridgeUrl, bridgeToken);
 }
 function createBashProgram(code, toolDefs, bridgeUrl, bridgeToken) {
-    const functions = toolDefs
-        .map((def) => {
-        const bashName = BashProgrammaticToolCalling.normalizeToBashIdentifier(def.name);
-        return [
-            `${bashName}() {`,
-            '  local payload="${1:-}"',
-            '  if [ -z "$payload" ]; then payload=\'{}\'; fi',
-            `  __librechat_call_tool ${LocalExecutionEngine.shellQuote(def.name)} "$payload"`,
-            '}',
-        ].join('\n');
-    })
-        .join('\n\n');
-    return `
-__LIBRECHAT_TOOL_BRIDGE=${LocalExecutionEngine.shellQuote(bridgeUrl)}
-__LIBRECHAT_TOOL_HEADER=${LocalExecutionEngine.shellQuote(BRIDGE_AUTH_HEADER)}
-__LIBRECHAT_TOOL_TOKEN=${LocalExecutionEngine.shellQuote(bridgeToken)}
+	const functions = toolDefs.map((def) => {
+		return [
+			`${require_BashProgrammaticToolCalling.normalizeToBashIdentifier(def.name)}() {`,
+			"  local payload=\"${1:-}\"",
+			"  if [ -z \"$payload\" ]; then payload='{}'; fi",
+			`  __librechat_call_tool ${require_LocalExecutionEngine.shellQuote(def.name)} "$payload"`,
+			"}"
+		].join("\n");
+	}).join("\n\n");
+	return `
+__LIBRECHAT_TOOL_BRIDGE=${require_LocalExecutionEngine.shellQuote(bridgeUrl)}
+__LIBRECHAT_TOOL_HEADER=${require_LocalExecutionEngine.shellQuote(BRIDGE_AUTH_HEADER)}
+__LIBRECHAT_TOOL_TOKEN=${require_LocalExecutionEngine.shellQuote(bridgeToken)}
 
 # Bridge call helper. Tries curl first (universally available, no
 # JSON parser needed thanks to the bridge's ?mode=text endpoint),
@@ -404,90 +343,83 @@ ${code}
 `.trimStart();
 }
 function getProgrammaticContext(config) {
-    return (config?.toolCall ?? {});
+	return config?.toolCall ?? {};
 }
 function createEffectiveToolMap(toolMap, toolDefs, code, filterTools) {
-    const effectiveTools = filterTools(toolDefs, code);
-    const effectiveMap = new Map(effectiveTools
-        .map((def) => {
-        const executable = toolMap.get(def.name);
-        return executable == null
-            ? undefined
-            : [def.name, executable];
-    })
-        .filter((entry) => entry != null));
-    return { effectiveTools, effectiveMap };
+	const effectiveTools = filterTools(toolDefs, code);
+	return {
+		effectiveTools,
+		effectiveMap: new Map(effectiveTools.map((def) => {
+			const executable = toolMap.get(def.name);
+			return executable == null ? void 0 : [def.name, executable];
+		}).filter((entry) => entry != null))
+	};
 }
 async function runLocalProgrammaticTool(args) {
-    const { toolMap, toolDefs, hookContext } = getProgrammaticContext(args.config);
-    if (toolMap == null || toolMap.size === 0) {
-        throw new Error('No toolMap provided for local programmatic execution.');
-    }
-    if (toolDefs == null || toolDefs.length === 0) {
-        throw new Error('No tool definitions provided for local programmatic execution.');
-    }
-    const { effectiveTools, effectiveMap } = createEffectiveToolMap(toolMap, toolDefs, args.params.code, args.runtime === 'bash' ? BashProgrammaticToolCalling.filterBashToolsByUsage : ProgrammaticToolCalling.filterToolsByUsage);
-    const bridge = await createToolBridge(effectiveMap, hookContext);
-    try {
-        const timeoutMs = args.params.timeout ?? args.localConfig.timeoutMs ?? DEFAULT_TIMEOUT;
-        const result = args.runtime === 'bash'
-            ? await LocalExecutionEngine.executeLocalBash(createBashProgram(args.params.code, effectiveTools, bridge.url, bridge.token), { ...args.localConfig, timeoutMs })
-            : await LocalExecutionEngine.executeLocalCode({
-                lang: 'py',
-                code: createPythonProgram(args.params.code, effectiveTools, bridge.url, bridge.token),
-            }, { ...args.localConfig, timeoutMs });
-        if (result.exitCode !== 0 || result.timedOut) {
-            throw new Error(result.stderr !== ''
-                ? result.stderr
-                : `Local ${args.runtime} programmatic execution exited with code ${result.exitCode ?? 'unknown'}`);
-        }
-        return ProgrammaticToolCalling.formatCompletedResponse({
-            status: 'completed',
-            session_id: LocalExecutionEngine.getLocalSessionId(args.localConfig),
-            stdout: result.stdout,
-            stderr: result.stderr,
-            files: [],
-        });
-    }
-    finally {
-        await bridge.close();
-    }
+	const { toolMap, toolDefs, hookContext } = getProgrammaticContext(args.config);
+	if (toolMap == null || toolMap.size === 0) throw new Error("No toolMap provided for local programmatic execution.");
+	if (toolDefs == null || toolDefs.length === 0) throw new Error("No tool definitions provided for local programmatic execution.");
+	const { effectiveTools, effectiveMap } = createEffectiveToolMap(toolMap, toolDefs, args.params.code, args.runtime === "bash" ? require_BashProgrammaticToolCalling.filterBashToolsByUsage : require_ProgrammaticToolCalling.filterToolsByUsage);
+	const bridge = await createToolBridge(effectiveMap, hookContext);
+	try {
+		const timeoutMs = args.params.timeout ?? args.localConfig.timeoutMs ?? DEFAULT_TIMEOUT;
+		const result = args.runtime === "bash" ? await require_LocalExecutionEngine.executeLocalBash(createBashProgram(args.params.code, effectiveTools, bridge.url, bridge.token), {
+			...args.localConfig,
+			timeoutMs
+		}) : await require_LocalExecutionEngine.executeLocalCode({
+			lang: "py",
+			code: createPythonProgram(args.params.code, effectiveTools, bridge.url, bridge.token)
+		}, {
+			...args.localConfig,
+			timeoutMs
+		});
+		if (result.exitCode !== 0 || result.timedOut) throw new Error(result.stderr !== "" ? result.stderr : `Local ${args.runtime} programmatic execution exited with code ${result.exitCode ?? "unknown"}`);
+		return require_ProgrammaticToolCalling.formatCompletedResponse({
+			status: "completed",
+			session_id: require_LocalExecutionEngine.getLocalSessionId(args.localConfig),
+			stdout: result.stdout,
+			stderr: result.stderr,
+			files: []
+		});
+	} finally {
+		await bridge.close();
+	}
 }
 function createLocalProgrammaticToolCallingTool(localConfig = {}) {
-    return tools.tool(async (rawParams, config) => {
-        const params = rawParams;
-        return runLocalProgrammaticTool({
-            params,
-            config,
-            localConfig,
-            runtime: resolveRuntime(params),
-        });
-    }, {
-        name: ProgrammaticToolCalling.ProgrammaticToolCallingName,
-        description: `${ProgrammaticToolCalling.ProgrammaticToolCallingDescription}\n\nLocal engine: runs bash by default, or Python when \`lang\` is \`py\` or \`python\`, on the host machine and calls tools through an in-process localhost bridge.`,
-        schema: createLocalProgrammaticToolCallingSchema(localConfig),
-        responseFormat: _enum.Constants.CONTENT_AND_ARTIFACT,
-    });
+	return (0, _langchain_core_tools.tool)(async (rawParams, config) => {
+		const params = rawParams;
+		return runLocalProgrammaticTool({
+			params,
+			config,
+			localConfig,
+			runtime: resolveRuntime(params)
+		});
+	}, {
+		name: require_ProgrammaticToolCalling.ProgrammaticToolCallingName,
+		description: `${require_ProgrammaticToolCalling.ProgrammaticToolCallingDescription}\n\nLocal engine: runs bash by default, or Python when \`lang\` is \`py\` or \`python\`, on the host machine and calls tools through an in-process localhost bridge.`,
+		schema: createLocalProgrammaticToolCallingSchema(localConfig),
+		responseFormat: "content_and_artifact"
+	});
 }
 function createLocalBashProgrammaticToolCallingTool(localConfig = {}) {
-    return tools.tool(async (rawParams, config) => {
-        const params = rawParams;
-        return runLocalProgrammaticTool({
-            params,
-            config,
-            localConfig,
-            runtime: 'bash',
-        });
-    }, {
-        name: _enum.Constants.BASH_PROGRAMMATIC_TOOL_CALLING,
-        description: `${BashProgrammaticToolCalling.BashProgrammaticToolCallingDescription}\n\nLocal engine: runs this bash orchestration code on the host machine and calls tools through an in-process localhost bridge.`,
-        schema: createLocalBashProgrammaticToolCallingSchema(localConfig),
-        responseFormat: _enum.Constants.CONTENT_AND_ARTIFACT,
-    });
+	return (0, _langchain_core_tools.tool)(async (rawParams, config) => {
+		return runLocalProgrammaticTool({
+			params: rawParams,
+			config,
+			localConfig,
+			runtime: "bash"
+		});
+	}, {
+		name: "run_tools_with_bash",
+		description: `${require_BashProgrammaticToolCalling.BashProgrammaticToolCallingDescription}\n\nLocal engine: runs this bash orchestration code on the host machine and calls tools through an in-process localhost bridge.`,
+		schema: createLocalBashProgrammaticToolCallingSchema(localConfig),
+		responseFormat: "content_and_artifact"
+	});
 }
-
+//#endregion
 exports._createBashProgramForTests = _createBashProgramForTests;
 exports.applyPreToolUseHooksForBridge = applyPreToolUseHooksForBridge;
 exports.createLocalBashProgrammaticToolCallingTool = createLocalBashProgrammaticToolCallingTool;
 exports.createLocalProgrammaticToolCallingTool = createLocalProgrammaticToolCallingTool;
-//# sourceMappingURL=LocalProgrammaticToolCalling.cjs.map
+
+//# sourceMappingURL=LocalProgrammaticToolCalling.cjs.map