@bike4mind/cli 0.18.5 → 0.20.1

package/dist/WorkItemsClient-Cow6nXx7.mjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+import { v4 } from "uuid";
+import { get_encoding } from "tiktoken";
+//#region src/utils/tokenCounter.ts
+const DEFAULT_CONTEXT_WINDOW = 2e5;
+const IMAGE_BLOCK_TOKEN_ESTIMATE = 1600;
+/**
+* Token counting utility for context window management.
+* Uses tiktoken (cl100k_base encoding) which works for Claude and GPT-4.
+*/
+var TokenCounter = class {
+	constructor() {
+		this.encoder = null;
+	}
+	getEncoder() {
+		if (!this.encoder) this.encoder = get_encoding("cl100k_base");
+		return this.encoder;
+	}
+	/**
+	* Count tokens in a text string
+	*/
+	countTokens(text) {
+		return this.getEncoder().encode_ordinary(text).length;
+	}
+	/**
+	* Count tokens in a message's content, whether it is a plain string or an
+	* array of structured blocks (text / tool_use / tool_result / image). Text is
+	* tiktoken-counted; images are billed a flat estimate since their bytes are
+	* opaque to the tokenizer.
+	*/
+	countMessageContent(content) {
+		if (typeof content === "string") return this.countTokens(content);
+		return content.reduce((sum, block) => {
+			switch (block.type) {
+				case "text": return sum + this.countTokens(block.text ?? "");
+				case "thinking": return sum + this.countTokens(block.thinking ?? "");
+				case "tool_use": return sum + this.countTokens(`${block.name ?? ""} ${JSON.stringify(block.input ?? {})}`);
+				case "tool_result": return sum + this.countTokens(block.content ?? "");
+				case "image":
+				case "image_url": return sum + IMAGE_BLOCK_TOKEN_ESTIMATE;
+				default: return sum;
+			}
+		}, 0);
+	}
+	/**
+	* Count tokens used in a session including system prompt
+	*/
+	countSessionTokens(session, systemPrompt) {
+		const systemPromptTokens = this.countTokens(systemPrompt);
+		const messageTokens = session.messages.reduce((sum, msg) => sum + this.countTokens(msg.content), 0);
+		return {
+			systemPromptTokens,
+			messageTokens,
+			totalTokens: systemPromptTokens + messageTokens
+		};
+	}
+	/**
+	* Get context window size for a model
+	* Falls back to DEFAULT_CONTEXT_WINDOW if model info not available
+	*/
+	getContextWindow(modelId, availableModels) {
+		return (availableModels?.find((m) => m.id === modelId))?.contextWindow || DEFAULT_CONTEXT_WINDOW;
+	}
+	/**
+	* Count tokens in tool schemas.
+	* Tool schemas are sent as part of the API call and consume context.
+	*/
+	countToolSchemaTokens(tools) {
+		if (tools.length === 0) return 0;
+		const schemaText = tools.map(({ toolSchema }) => `Tool: ${toolSchema.name}\nDescription: ${toolSchema.description}\nParameters: ${JSON.stringify(toolSchema.parameters)}`).join("\n\n");
+		return this.countTokens(schemaText);
+	}
+	/**
+	* Free encoder resources when done
+	*/
+	dispose() {
+		if (this.encoder) {
+			this.encoder.free();
+			this.encoder = null;
+		}
+	}
+};
+let tokenCounter = null;
+/**
+* Get the singleton TokenCounter instance
+*/
+function getTokenCounter() {
+	if (!tokenCounter) tokenCounter = new TokenCounter();
+	return tokenCounter;
+}
+/** Max characters of a single tool input/result rendered into a replay line. */
+const TOOL_TRACE_FIELD_CHARS = 400;
+/**
+* Owns the whole "session messages -> LLM messages" transformation behind a
+* narrow interface. It is the single place that decides how much history a turn
+* gets, maps the persisted model to the agent's IMessage type without losing the
+* tool trace, bounds tool-trace replay, and serializes back for persistence.
+*
+* Persistence keeps the rich form (tool_use / tool_result blocks) losslessly on
+* `Message.richContent`. Replay renders each past turn's tool trace into a
+* bounded text appendix rather than emitting raw provider-native tool blocks,
+* which would need exact assistant/user pairing and could re-bloat context.
+*/
+var ConversationContext = class ConversationContext {
+	constructor(session, counter) {
+		this.base = session;
+		this.messages = [...session.messages];
+		this.counter = counter;
+	}
+	/**
+	* Back-compat read: loads a session as-is. Legacy string-only messages need no
+	* upgrade - they are read through `content` and only wrapped into blocks lazily
+	* when a turn actually carries a `richContent` trace.
+	*/
+	static fromSession(session, counter = getTokenCounter()) {
+		return new ConversationContext(session, counter);
+	}
+	/**
+	* Append a completed turn. Persists the RICH form: the user message (text, or
+	* multimodal blocks preserved on `richContent`) and the assistant message with
+	* its tool_use / tool_result trace on `richContent`, plus the final answer as
+	* the display `content`.
+	*/
+	recordTurn(turn) {
+		this.messages.push(this.buildUserMessage(turn.userInput));
+		this.messages.push(this.buildAssistantMessage(turn.result));
+	}
+	/**
+	* The one place that builds the IMessage[] for the next turn. Returns the
+	* windowed history followed by the current input as the final user message.
+	* Windowing is token-aware: it reserves room for the system prompt, the
+	* response, and the current input, then fills from the most recent turn
+	* backward, dropping the oldest turns first. The current input is never
+	* dropped (the protected suffix).
+	*/
+	buildTurnMessages(newInput, opts) {
+		return [...this.windowedHistory(newInput, opts), this.inputToIMessage(newInput)];
+	}
+	/**
+	* The windowed history only, WITHOUT the current input appended. Convenience
+	* for hosts whose agent API takes the current input as a separate query and
+	* the history as `previousMessages` (e.g. the CLI's `agent.run`). Budgeting
+	* still reserves room for `newInput`, so the two together fit the window.
+	*/
+	buildPreviousMessages(newInput, opts) {
+		return this.windowedHistory(newInput, opts);
+	}
+	/**
+	* Whether the session should be compacted before the next turn. Measures the
+	* FULL session (not the windowed subset) as it would actually be sent -
+	* rendering each turn's bounded tool trace - plus the system prompt, and
+	* compares against `thresholdRatio` of the context window. Rich-content aware:
+	* replaces the old string-only `content` sum so a session whose weight lives
+	* in tool traces still triggers compaction.
+	*/
+	needsCompaction(systemPromptTokens, opts, thresholdRatio = .8) {
+		return this.estimateSessionTokens(systemPromptTokens, opts) >= opts.contextWindow * thresholdRatio;
+	}
+	/**
+	* Rich-aware token estimate for the whole session as it would be replayed:
+	* every user/assistant turn rendered (bounded tool traces included) plus the
+	* system prompt. Used by `needsCompaction`.
+	*/
+	estimateSessionTokens(systemPromptTokens, opts) {
+		return systemPromptTokens + this.messages.filter((m) => m.role === "user" || m.role === "assistant").reduce((sum, m) => sum + this.estimateTokens(this.renderHistoryMessage(m, opts)), 0);
+	}
+	/** Serialize back to a Session for on-disk persistence (rich content preserved). */
+	toSession() {
+		return {
+			...this.base,
+			messages: this.messages,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	/**
+	* The most-recent contiguous window of history that fits the token budget
+	* after reserving room for the system prompt, the response, and the current
+	* input. Fills newest-first and stops at the first turn that no longer fits,
+	* so the oldest turns are dropped first and the current input is never
+	* crowded out.
+	*/
+	windowedHistory(newInput, opts) {
+		const reserved = opts.reservedTokens ?? 8e3;
+		const currentTokens = this.estimateTokens(this.inputToIMessage(newInput));
+		const history = this.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => this.renderHistoryMessage(m, opts));
+		let remaining = opts.contextWindow - reserved - currentTokens;
+		const kept = [];
+		for (let i = history.length - 1; i >= 0; i--) {
+			const cost = this.estimateTokens(history[i]);
+			if (cost > remaining) break;
+			remaining -= cost;
+			kept.unshift(history[i]);
+		}
+		return kept;
+	}
+	buildUserMessage(input) {
+		const base = {
+			id: v4(),
+			role: "user",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (typeof input === "string") return {
+			...base,
+			content: input
+		};
+		const text = input.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+		return {
+			...base,
+			content: text,
+			richContent: input
+		};
+	}
+	buildAssistantMessage(result) {
+		const richContent = reconstructTurnBlocks(result.steps, result.finalAnswer);
+		return {
+			id: v4(),
+			role: "assistant",
+			content: result.finalAnswer,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...richContent ? { richContent } : {}
+		};
+	}
+	/** Map a persisted message to the IMessage the agent replays as history. */
+	renderHistoryMessage(message, opts) {
+		const role = message.role === "assistant" ? "assistant" : "user";
+		if (!message.richContent) return {
+			role,
+			content: message.content
+		};
+		if (role === "user") return {
+			role,
+			content: message.richContent
+		};
+		return {
+			role,
+			content: this.renderAssistantTrace(message, opts)
+		};
+	}
+	renderAssistantTrace(message, opts) {
+		const blocks = message.richContent ?? [];
+		const budget = opts.toolTraceReplayTokens ?? 1500;
+		const textBlocks = blocks.filter((b) => b.type === "text").map((b) => b.text ?? "");
+		const finalText = textBlocks.length > 0 ? textBlocks.join("\n") : message.content;
+		const results = /* @__PURE__ */ new Map();
+		for (const b of blocks) if (b.type === "tool_result" && b.tool_use_id) results.set(b.tool_use_id, b.content ?? "");
+		const lines = [];
+		let used = 0;
+		let omitted = 0;
+		for (const b of blocks) {
+			if (b.type !== "tool_use") continue;
+			const resultText = b.id && results.get(b.id) || "";
+			const line = `[tool ${b.name}] ${this.brief(JSON.stringify(b.input ?? {}))} -> ${this.brief(resultText)}`;
+			const cost = this.counter.countTokens(line);
+			if (used + cost > budget) {
+				omitted++;
+				continue;
+			}
+			used += cost;
+			lines.push(line);
+		}
+		if (omitted > 0) lines.push(`[... ${omitted} more tool call${omitted === 1 ? "" : "s"} omitted]`);
+		if (lines.length === 0) return finalText;
+		return `${finalText}\n\n<tool-trace>\n${lines.join("\n")}\n</tool-trace>`;
+	}
+	brief(text) {
+		if (text.length <= TOOL_TRACE_FIELD_CHARS) return text;
+		return `${text.slice(0, TOOL_TRACE_FIELD_CHARS)}... (+${text.length - TOOL_TRACE_FIELD_CHARS} chars)`;
+	}
+	inputToIMessage(input) {
+		return {
+			role: "user",
+			content: input
+		};
+	}
+	estimateTokens(message) {
+		return this.counter.countMessageContent(message.content);
+	}
+};
+/**
+* Reconstruct tool_use / tool_result blocks from the agent's steps, pairing
+* each observation to the earliest still-unmatched action (FIFO). This is exact
+* for sequential tool use; with parallel execution the pairing is best-effort by
+* order, which is fine for context replay. Returns undefined when the turn used
+* no tools (so the message stays string-only and round-trips like a legacy one).
+*
+* Exported so hosts that manage their own message store (e.g. the CLI's live
+* pending-message UI) can attach the rich trace to their assistant message
+* without going through `recordTurn`.
+*/
+function reconstructTurnBlocks(steps, finalAnswer) {
+	const blocks = [];
+	const pendingIds = [];
+	let toolCounter = 0;
+	for (const step of steps) if (step.type === "action") {
+		const id = `tu_${toolCounter++}`;
+		pendingIds.push(id);
+		const toolUse = {
+			type: "tool_use",
+			id,
+			name: step.metadata?.toolName ?? "unknown",
+			input: normalizeToolInput(step.metadata?.toolInput)
+		};
+		blocks.push(toolUse);
+	} else if (step.type === "observation") {
+		const toolResult = {
+			type: "tool_result",
+			tool_use_id: pendingIds.shift() ?? `tu_${toolCounter++}`,
+			content: typeof step.content === "string" ? step.content : String(step.content ?? "")
+		};
+		blocks.push(toolResult);
+	}
+	if (blocks.length === 0) return void 0;
+	blocks.push({
+		type: "text",
+		text: finalAnswer
+	});
+	return blocks;
+}
+function normalizeToolInput(input) {
+	if (input && typeof input === "object" && !Array.isArray(input)) return input;
+	if (typeof input === "string") {
+		try {
+			const parsed = JSON.parse(input);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+		return { value: input };
+	}
+	return {};
+}
+//#endregion
+//#region src/api/WorkItemsClient.ts
+var WorkItemsClient = class {
+	constructor(apiClient) {
+		this.apiClient = apiClient;
+	}
+	async list(params = {}) {
+		const search = new URLSearchParams();
+		if (params.status?.length) search.set("status", params.status.join(","));
+		if (params.organizationId) search.set("organizationId", params.organizationId);
+		if (params.query) search.set("query", params.query);
+		if (params.page !== void 0) search.set("page", String(params.page));
+		if (params.limit !== void 0) search.set("limit", String(params.limit));
+		if (params.orderBy) search.set("orderBy", params.orderBy);
+		if (params.orderDirection) search.set("orderDirection", params.orderDirection);
+		const suffix = search.size > 0 ? `?${search.toString()}` : "";
+		return this.apiClient.get(`/api/work-items${suffix}`);
+	}
+	async get(id) {
+		return this.apiClient.get(`/api/work-items/${encodeURIComponent(id)}`);
+	}
+	async create(input) {
+		return this.apiClient.post("/api/work-items", input);
+	}
+	async update(id, input) {
+		return (await this.apiClient.getAxiosInstance().patch(`/api/work-items/${encodeURIComponent(id)}`, input)).data;
+	}
+	/** Convenience for the common `status: 'closed'` transition. */
+	async close(id) {
+		return this.update(id, { status: "closed" });
+	}
+	/** Soft delete - the item stops appearing in listings but is not erased. */
+	async remove(id) {
+		await this.apiClient.delete(`/api/work-items/${encodeURIComponent(id)}`);
+	}
+	/**
+	* Open items whose dependencies are all closed. `truncated` means the backlog
+	* exceeded the server's whole-graph read window, so the answer is computed
+	* from a prefix and can be wrong (see IWorkItemReadyResult).
+	*/
+	async ready() {
+		const response = await this.apiClient.get("/api/work-items/ready");
+		return {
+			data: response?.data ?? [],
+			truncated: response?.truncated ?? false
+		};
+	}
+	async graph() {
+		return this.apiClient.get("/api/work-items/graph");
+	}
+};
+//#endregion
+export { getTokenCounter as i, ConversationContext as n, reconstructTurnBlocks as r, WorkItemsClient as t };

package/dist/{bashExecute-B1N1lMOS-TZVDbcQ4.mjs → bashExecute-CrdPpBqk-DCATrE-D.mjs}

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
+import { n as isTerminalShellStatus, t as getShellSessionManager } from "./ShellSessionManager-6o8KZzl1-vrbPAUTq.mjs";
 import { spawn } from "child_process";
 import path from "path";
-//#region ../../b4m-core/services/dist/bashExecute-B1N1lMOS.mjs
+import { StringDecoder } from "string_decoder";
+//#region ../../b4m-core/services/dist/bashExecute-CrdPpBqk.mjs
 const DEFAULT_TIMEOUT_MS = 6e4;
-const MAX_OUTPUT_SIZE = 100 * 1024;
+const MAX_OUTPUT_SIZE = 102400;
 /**
 * Dangerous command patterns that should be blocked or warned about.
 * These patterns are checked against the full command string.
@@ -263,11 +265,16 @@ function isSafeCommandPrefix(command) {
 	const baseCommand = getBaseCommand(command);
 	return SAFE_COMMAND_PREFIXES.some((safe) => baseCommand === safe || baseCommand.endsWith(`/${safe}`));
 }
+/** Max hard timeout for a foreground command (5 minutes). */
+const MAX_FOREGROUND_TIMEOUT_MS = 3e5;
+/** Grace window before a `run_in_background` command returns its session id. */
+const BACKGROUND_GRACE_MS = 250;
 /**
-* Execute a bash command with safety checks
+* Run the empty-command and dangerous-pattern safety checks shared by the
+* foreground and background paths. Returns a blocked result, or null if the
+* command may proceed.
 */
-async function executeBashCommand(params) {
-	const { command, cwd: relativeCwd, timeout = DEFAULT_TIMEOUT_MS } = params;
+function precheckCommand(command) {
 	if (!command || command.trim().length === 0) return {
 		stdout: "",
 		stderr: "Error: Command cannot be empty",
@@ -285,20 +292,39 @@ async function executeBashCommand(params) {
 		blocked: true,
 		blockedReason: dangerCheck.reason
 	};
+	return null;
+}
+/** Resolve a (possibly relative) cwd against the process cwd. */
+function resolveCwd(relativeCwd) {
 	const baseCwd = process.cwd();
-	const targetCwd = relativeCwd ? path.resolve(baseCwd, relativeCwd) : baseCwd;
-	const effectiveTimeout = Math.min(timeout, 300 * 1e3);
+	return relativeCwd ? path.resolve(baseCwd, relativeCwd) : baseCwd;
+}
+/** Environment for spawned commands: inherit, but suppress color codes. */
+function buildEnv() {
+	return {
+		...process.env,
+		NO_COLOR: "1",
+		FORCE_COLOR: "0"
+	};
+}
+/**
+* Execute a bash command with safety checks (foreground, blocking).
+*/
+async function executeBashCommand(params) {
+	const { command, cwd: relativeCwd, timeout = DEFAULT_TIMEOUT_MS } = params;
+	const blocked = precheckCommand(command);
+	if (blocked) return blocked;
+	const targetCwd = resolveCwd(relativeCwd);
+	const effectiveTimeout = Math.min(timeout, MAX_FOREGROUND_TIMEOUT_MS);
 	return new Promise((resolve) => {
 		let stdout = "";
 		let stderr = "";
 		let timedOut = false;
+		const outDecoder = new StringDecoder("utf8");
+		const errDecoder = new StringDecoder("utf8");
 		const proc = spawn("bash", ["-c", command], {
 			cwd: targetCwd,
-			env: {
-				...process.env,
-				NO_COLOR: "1",
-				FORCE_COLOR: "0"
-			},
+			env: buildEnv(),
 			stdio: [
 				"ignore",
 				"pipe",
@@ -314,18 +340,20 @@ async function executeBashCommand(params) {
 		}, effectiveTimeout);
 		proc.stdout.on("data", (data) => {
 			if (stdout.length < MAX_OUTPUT_SIZE) {
-				stdout += data.toString();
+				stdout += outDecoder.write(data);
 				if (stdout.length > MAX_OUTPUT_SIZE) stdout = stdout.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
 			}
 		});
 		proc.stderr.on("data", (data) => {
 			if (stderr.length < MAX_OUTPUT_SIZE) {
-				stderr += data.toString();
+				stderr += errDecoder.write(data);
 				if (stderr.length > MAX_OUTPUT_SIZE) stderr = stderr.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
 			}
 		});
 		proc.on("close", (exitCode) => {
 			clearTimeout(timeoutId);
+			stdout += outDecoder.end();
+			stderr += errDecoder.end();
 			resolve({
 				stdout: stdout.trim(),
 				stderr: stderr.trim(),
@@ -377,6 +405,55 @@ function formatResult(result, command) {
 	if (!result.stdout && !result.stderr && !result.timedOut) parts.push("(command completed with no output)");
 	return parts.join("\n");
 }
+/** Resolve when the session reaches a terminal status, or after `timeoutMs`. */
+function waitForSettleOrTimeout(manager, sessionId, timeoutMs) {
+	return new Promise((resolve) => {
+		const current = manager.get(sessionId);
+		if (!current || isTerminalShellStatus(current.status)) {
+			resolve(current);
+			return;
+		}
+		const finish = () => {
+			clearTimeout(timer);
+			unsubscribe();
+			resolve(manager.get(sessionId));
+		};
+		const timer = setTimeout(finish, timeoutMs);
+		const unsubscribe = manager.subscribe((session) => {
+			if (session.id === sessionId && isTerminalShellStatus(session.status)) finish();
+		});
+	});
+}
+/** Format the outcome of a background/yield session for the model. */
+function formatSessionResult(session, output) {
+	const parts = [`$ ${session.command}`, ""];
+	if (isTerminalShellStatus(session.status)) {
+		const exit = session.exitCode === null ? session.status : `exit ${session.exitCode}`;
+		parts.push(`[session ${session.id} finished: ${exit}]`);
+		if (output.trim()) parts.push("", output.trim());
+		else parts.push("", "(no output)");
+		return parts.join("\n");
+	}
+	parts.push(`[background session started: ${session.id} - still running]`);
+	parts.push(`Poll with check_shell_output (session_id: "${session.id}"), send input with write_shell_stdin, stop with kill_background_shell.`);
+	if (output.trim()) parts.push("", "Output so far:", output.trim());
+	return parts.join("\n");
+}
+/**
+* Run a command as a shell session, waiting up to `waitMs` for it to settle.
+* Returns the full output if it finishes in time, otherwise a session id to poll.
+*/
+async function executeBackgroundSession(params, waitMs, manager = getShellSessionManager()) {
+	const blocked = precheckCommand(params.command);
+	if (blocked) return formatResult(blocked, params.command);
+	let session;
+	try {
+		session = manager.spawn(params.command, resolveCwd(params.cwd), buildEnv());
+	} catch (error) {
+		return `$ ${params.command}\n\n[cannot start background session] ${error instanceof Error ? error.message : String(error)}`;
+	}
+	return formatSessionResult(await waitForSettleOrTimeout(manager, session.id, waitMs) ?? session, manager.getOutput(session.id)?.output ?? "");
+}
 const bashExecuteTool = {
 	name: "bash_execute",
 	implementation: (context) => ({
@@ -394,6 +471,14 @@ const bashExecuteTool = {
 				cwd: params.cwd
 			});
 			try {
+				if (params.run_in_background === true || typeof params.yield_time_ms === "number") {
+					const sessionResult = await executeBackgroundSession(params, params.run_in_background ? BACKGROUND_GRACE_MS : Math.min(Math.max(params.yield_time_ms ?? BACKGROUND_GRACE_MS, 0), MAX_FOREGROUND_TIMEOUT_MS));
+					if (context.onFinish) await context.onFinish("bash_execute", {
+						command: params.command,
+						background: true
+					});
+					return sessionResult;
+				}
 				const result = await executeBashCommand(params);
 				const formattedResult = formatResult(result, params.command);
 				context.logger.info("Bash: Command completed", {
@@ -427,6 +512,13 @@ SAFETY NOTES:
 - Output is limited to prevent overwhelming responses
 - This tool ALWAYS requires user permission before execution
 
+LONG-RUNNING / BACKGROUND COMMANDS:
+- Set run_in_background: true for dev servers, watchers, or anything long-lived. Returns a
+  session_id immediately instead of blocking. Then poll it with check_shell_output, feed it
+  input with write_shell_stdin, and stop it with kill_background_shell.
+- Set yield_time_ms to run a command in the foreground but, if it is still going after that
+  window, hand back a session_id (and keep it running) instead of killing it at the timeout.
+
 COMMON USE CASES:
 - Running build commands: npm run build, make, cargo build
 - Git operations: git status, git log, git diff
@@ -454,7 +546,15 @@ BLOCKED OPERATIONS:
 					},
 					timeout: {
 						type: "number",
-						description: "Timeout in milliseconds (optional, default: 60000, max: 300000). Command will be terminated if it exceeds this time."
+						description: "Timeout in milliseconds (optional, default: 60000, max: 300000). Command will be terminated if it exceeds this time. Ignored in background/yield mode."
+					},
+					run_in_background: {
+						type: "boolean",
+						description: "Optional. Start the command as a background session and return a session_id immediately (for dev servers, watchers, long builds). Poll with check_shell_output."
+					},
+					yield_time_ms: {
+						type: "number",
+						description: "Optional. Run in the foreground but, if still running after this many ms, return a session_id and keep it running instead of killing it."
 					}
 				},
 				required: ["command"]
@@ -463,4 +563,4 @@ BLOCKED OPERATIONS:
 	})
 };
 //#endregion
-export { bashExecuteTool };
+export { bashExecuteTool, executeBackgroundSession, executeBashCommand, formatSessionResult };