@bike4mind/cli 1.0.0 → 1.2.0

package/dist/buildAgent-C-C-VGff.mjs

@@ -0,0 +1,2001 @@
+#!/usr/bin/env node
+import { I as generateCliTools, J as setWebSocketToolExecutor, L as wrapTools, N as ReActAgent, X as buildSystemPrompt, Y as getPlanModeFilePath, a as loadProjectContext, c as createSseBackend, i as buildProjectAgentStore, it as Logger, l as ServerLlmBackend, n as BackgroundAgentManager, o as McpManager, r as SubagentOrchestrator, t as AgentHistoryStore } from "./AgentHistoryStore-B2NEOvSW.mjs";
+import { D as MODEL_INFO_FIELD_GROUP_OF, H as escapeThinkMarkers, P as PermissionDeniedError, S as CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS, V as createThinkMarkerEscaper, W as getQuestErrorCode, Y as isUserInitiatedAbort, k as ModelBackend, n as logger, w as ChatModels } from "./ConfigStore-qV7NrCgZ.mjs";
+import "crypto";
+import { v4 } from "uuid";
+import { z as z$1 } from "zod";
+import "axios";
+import "@aws-sdk/client-bedrock-runtime";
+import "openai";
+import "@anthropic-ai/sdk";
+import "@aws-sdk/client-cloudwatch";
+import "@google/genai";
+import "lodash/pick.js";
+import "openai/streaming";
+import { Ollama } from "ollama";
+import { Agent } from "undici";
+import WebSocket from "ws";
+//#region ../../b4m-core/llm-adapters/dist/index.mjs
+/**
+* A tool failure that must end the turn rather than be fed back to the model as a
+* recoverable observation: a declined tool (PermissionDeniedError) or an out-of-credits
+* error (tagged via `getQuestErrorCode`), neither of which any retry can satisfy.
+*/
+function isTerminalToolError(error) {
+	return error instanceof PermissionDeniedError || getQuestErrorCode(error) !== void 0;
+}
+/**
+* Execute an array of async tasks either in parallel (with concurrency limiting)
+* or sequentially, returning outcomes in the original order.
+*
+* Terminal errors (see isTerminalToolError) are always re-thrown immediately: sequential
+* breaks the loop on the first one; parallel runs every task to completion (inherent to
+* Promise.allSettled) then pre-scans outcomes before returning - accepted because these
+* errors are rare in multi-tool batches.
+*
+* Fault isolation: uses Promise.allSettled so a single failure doesn't abort the batch.
+* Order preservation: results are indexed back to the original task array.
+*/
+async function executeToolsBatch(tasks, options) {
+	const { parallel, maxConcurrency = 8 } = options;
+	if (parallel && tasks.length > 1) {
+		const outcomes = (await runWithConcurrency(tasks, maxConcurrency)).map((s) => s.status === "fulfilled" ? {
+			ok: true,
+			result: s.value
+		} : {
+			ok: false,
+			error: s.reason
+		});
+		for (const outcome of outcomes) if (!outcome.ok && isTerminalToolError(outcome.error)) throw outcome.error;
+		return outcomes;
+	}
+	const outcomes = [];
+	for (const task of tasks) try {
+		const result = await task();
+		outcomes.push({
+			ok: true,
+			result
+		});
+	} catch (error) {
+		if (isTerminalToolError(error)) throw error;
+		outcomes.push({
+			ok: false,
+			error
+		});
+	}
+	return outcomes;
+}
+/**
+* Run tasks with bounded concurrency using a worker-pool pattern.
+* Spawns up to `limit` workers that pull from a shared task queue.
+* Results are stored by index to preserve original ordering.
+*/
+async function runWithConcurrency(tasks, limit) {
+	if (limit >= tasks.length) return Promise.allSettled(tasks.map((fn) => fn()));
+	const results = new Array(tasks.length);
+	let nextIndex = 0;
+	async function worker() {
+		while (nextIndex < tasks.length) {
+			const index = nextIndex++;
+			try {
+				results[index] = {
+					status: "fulfilled",
+					value: await tasks[index]()
+				};
+			} catch (reason) {
+				results[index] = {
+					status: "rejected",
+					reason
+				};
+			}
+		}
+	}
+	const workerCount = Math.min(limit, tasks.length);
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results;
+}
+/**
+* Attaches a tool call's outcome onto its `toolsUsed` entry so it survives into
+* `promptMeta.functionCalls.returnValue`/`.success` (see ChatCompletionProcess.ts's mapper
+* and utils.ts's `replayableToolCalls`, which gates a whole replay path on at least one
+* recorded `returnValue`). Every backend pushes a `toolsUsed` entry before executing the
+* tool and only learns the real outcome a few lines later - this is the merge-back.
+*/
+/**
+* Cap applied to a persisted `returnValue` before it reaches Mongo (chars, not bytes). Also the
+* cap on what a later turn replays back to the model for this call (utils.ts's Priority 2
+* reconstruction reads the same persisted, already-truncated value) - this is not a
+* persistence-only limit, it is what a continued conversation sees of an older tool result too.
+*/
+const MAX_RECORDED_TOOL_RESULT_CHARS = 8e3;
+const TOOL_RESULT_TRUNCATION_NOTICE = "\n[tool result truncated]";
+/** Cap on the in-memory full result (chars). */
+const MAX_FULL_TOOL_RESULT_CHARS = 2e5;
+const FULL_TOOL_RESULT_KEY = "__b4mFullToolResult";
+function truncateToolResult(observation) {
+	if (observation.length <= 8e3) return observation;
+	return observation.slice(0, MAX_RECORDED_TOOL_RESULT_CHARS) + TOOL_RESULT_TRUNCATION_NOTICE;
+}
+/**
+* Keeps the untruncated result on the entry for the reply parser's echo check (see
+* buildToolEchoSources in services). It is non-enumerable so JSON.stringify and spreads skip it:
+* `toolsUsed` also leaves the process whole (Research Mode streams each callback's completionInfo
+* over the websocket, where API Gateway caps a post at 128 KB), and it must never be persisted.
+*/
+function attachFullToolResult(entry, observation) {
+	const text = String(observation);
+	const value = {
+		text: text.slice(0, MAX_FULL_TOOL_RESULT_CHARS),
+		truncated: text.length > MAX_FULL_TOOL_RESULT_CHARS
+	};
+	Object.defineProperty(entry, FULL_TOOL_RESULT_KEY, {
+		value,
+		enumerable: false,
+		configurable: true,
+		writable: true
+	});
+}
+/**
+* Drops the messages whose instructions assume a tool is attached (see `IMessage.requiresTool`).
+*
+* Call this wherever a turn continues with tools removed. Re-sending "you MUST use the X tool" on a
+* call that carries no tools leaves the model no valid move, and it answers by emitting the tool call
+* as text in the reply - which is exactly what the callers that inject those prompts gate against
+* when they decide whether to add them in the first place.
+*
+* Drops on the presence of the marker, not on which tool it names, because every call site today
+* removes the whole tool set at once. A site that ever drops only SOME tools would need to compare
+* `requiresTool` against the survivors instead.
+*/
+const stripToolDependentMessages = (messages) => messages.filter((message) => !message.requiresTool);
+/**
+* Anthropic's hard ceiling on `cache_control` markers per request. Exceeding it fails the
+* WHOLE request with `ValidationException: A maximum of 4 blocks with cache_control may be
+* provided`, which is non-retryable - so an over-budget request loses the turn outright,
+* after the user has already waited for it.
+*/
+const MAX_CACHE_CONTROL_BLOCKS = 4;
+/**
+* Does this block already carry a marker? Re-marking one costs no budget.
+*
+* Tests the VALUE, not just key presence: a block carrying an explicit
+* `cache_control: undefined` is not a marker as far as the provider is concerned, and counting
+* it would spend budget on nothing and drop a breakpoint we could have kept.
+*/
+function hasMarker(block) {
+	return !!block && typeof block === "object" && !!block.cache_control;
+}
+/**
+* Markers already on the request. Callers upstream attach their own before this runs -
+* `bedrockBackend/anthropic.ts` marks each system block flagged `cache: true` (the mid-stack
+* shareable-prefix breakpoint) - so this adapter's budget is whatever they left, not the full four.
+*/
+function censusMarkers(params) {
+	const tools = Array.isArray(params.tools) ? params.tools.filter(hasMarker).length : 0;
+	const system = Array.isArray(params.system) ? params.system.filter(hasMarker).length : 0;
+	let messages = 0;
+	if (Array.isArray(params.messages)) for (const message of params.messages) {
+		const content = message?.content;
+		if (Array.isArray(content)) messages += content.filter(hasMarker).length;
+	}
+	return {
+		tools,
+		system,
+		messages,
+		total: tools + system + messages
+	};
+}
+/**
+* Anthropic-specific caching adapter
+* Adds explicit cache_control markers to content blocks
+*/
+var AnthropicCachingAdapter = class {
+	applyCaching(apiParams, strategy, logger) {
+		if (!strategy.enableCaching) return apiParams;
+		const ttl = strategy.cacheTTL ?? "5m";
+		const modifiedParams = { ...apiParams };
+		const cacheControl = {
+			type: "ephemeral",
+			...ttl === "1h" ? { ttl } : {}
+		};
+		const inbound = censusMarkers(modifiedParams);
+		let budget = MAX_CACHE_CONTROL_BLOCKS - inbound.total;
+		const dropped = [];
+		/** Claim one marker slot, or record the miss. Re-marking a marked block is free. */
+		const claim = (name, alreadyMarked) => {
+			if (alreadyMarked) return true;
+			if (budget <= 0) {
+				dropped.push(name);
+				return false;
+			}
+			budget -= 1;
+			return true;
+		};
+		const systemParam = modifiedParams.system;
+		if (strategy.cacheSystemPrompt && systemParam) {
+			const systemArray = Array.isArray(systemParam) ? [...systemParam] : [{
+				type: "text",
+				text: systemParam
+			}];
+			if (systemArray.length > 0) {
+				const lastBlock = systemArray[systemArray.length - 1];
+				if (claim("system", hasMarker(lastBlock))) {
+					systemArray[systemArray.length - 1] = {
+						...lastBlock,
+						cache_control: cacheControl
+					};
+					modifiedParams.system = systemArray;
+				}
+			}
+		}
+		const messagesParam = modifiedParams.messages;
+		if (strategy.cacheConversationHistory && Array.isArray(messagesParam) && messagesParam.length > 0) {
+			const messages = [...messagesParam];
+			const anchorIndex = messages.length - 1 - (strategy.historyCacheExcludeTrailingCount ?? 0);
+			if (anchorIndex >= 0) {
+				const anchorMsg = messages[anchorIndex];
+				const msgContent = anchorMsg.content;
+				let contentArray;
+				if (typeof msgContent === "string") contentArray = [{
+					type: "text",
+					text: msgContent
+				}];
+				else if (Array.isArray(msgContent)) contentArray = [...msgContent];
+				if (contentArray && contentArray.length > 0) {
+					const lastBlock = contentArray[contentArray.length - 1];
+					if (claim("history", hasMarker(lastBlock))) {
+						contentArray[contentArray.length - 1] = {
+							...lastBlock,
+							cache_control: cacheControl
+						};
+						messages[anchorIndex] = {
+							...anchorMsg,
+							content: contentArray
+						};
+						modifiedParams.messages = messages;
+					}
+				}
+			}
+		}
+		const tools = modifiedParams.tools;
+		if (strategy.cacheTools && Array.isArray(tools) && tools.length > 0) {
+			const toolsCopy = [...tools];
+			const lastTool = toolsCopy[toolsCopy.length - 1];
+			if (claim("tools", hasMarker(lastTool))) {
+				toolsCopy[toolsCopy.length - 1] = {
+					...lastTool,
+					cache_control: cacheControl
+				};
+				modifiedParams.tools = toolsCopy;
+			}
+		}
+		const outbound = censusMarkers(modifiedParams);
+		const census = {
+			inbound,
+			outbound,
+			limit: MAX_CACHE_CONTROL_BLOCKS
+		};
+		if (outbound.total >= MAX_CACHE_CONTROL_BLOCKS) {
+			const message = "[PromptCache] cache_control census at the ceiling";
+			if (logger) logger.info(message, census);
+			else console.info(message, JSON.stringify(census));
+		} else if (logger) logger.debug("[PromptCache] cache_control census", census);
+		if (outbound.total > MAX_CACHE_CONTROL_BLOCKS) {
+			const message = `[PromptCache] request exceeds the ${MAX_CACHE_CONTROL_BLOCKS}-block cache_control limit on arrival (${outbound.total}); the provider will reject it`;
+			const detail = {
+				inbound,
+				outbound,
+				limit: MAX_CACHE_CONTROL_BLOCKS
+			};
+			if (logger) logger.error(message, detail);
+			else console.error(message, JSON.stringify(detail));
+		} else if (dropped.length > 0) {
+			const message = `[PromptCache] cache_control budget exhausted (limit ${MAX_CACHE_CONTROL_BLOCKS}); skipped breakpoints: ${dropped.join(", ")}`;
+			const detail = {
+				dropped,
+				inbound,
+				outbound,
+				limit: MAX_CACHE_CONTROL_BLOCKS
+			};
+			if (logger) logger.warn(message, detail);
+			else console.warn(message, JSON.stringify(detail));
+		}
+		return modifiedParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const cacheReadTokens = usage.cache_read_input_tokens || 0;
+		const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
+		const uncachedTokens = usage.input_tokens || 0;
+		const totalInputTokens = cacheReadTokens + cacheWriteTokens + uncachedTokens;
+		const cacheHitRate = totalInputTokens > 0 ? cacheReadTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .9;
+		const estimatedLatencyReduction = cacheHitRate * .85;
+		return {
+			provider: ModelBackend.Anthropic,
+			model,
+			totalInputTokens,
+			cacheReadTokens,
+			cacheWriteTokens,
+			uncachedTokens,
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: { hadCacheWrite: cacheWriteTokens > 0 }
+		};
+	}
+};
+/**
+* OpenAI-specific caching adapter
+* OpenAI caching is AUTOMATIC - no explicit markers needed
+* Just ensure static content is at the beginning of prompts
+*/
+var OpenAICachingAdapter = class {
+	applyCaching(apiParams, strategy) {
+		return apiParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.prompt_tokens || 0;
+		const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .9;
+		const estimatedLatencyReduction = cacheHitRate * .8;
+		return {
+			provider: ModelBackend.OpenAI,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: totalInputTokens - cachedTokens,
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: { automatic: true }
+		};
+	}
+};
+/**
+* Gemini-specific caching adapter
+* Gemini 2.5+ supports IMPLICIT (automatic) caching by default
+* Explicit caching via Vertex AI API is optional (not implemented yet)
+*/
+var GeminiCachingAdapter = class {
+	applyCaching(apiParams, strategy) {
+		return apiParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usageMetadata;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.promptTokenCount || 0;
+		const cachedTokens = usage.cachedContentTokenCount || 0;
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * (model.includes("2.5") ? .9 : .75);
+		const estimatedLatencyReduction = cacheHitRate * .75;
+		return {
+			provider: ModelBackend.Gemini,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: totalInputTokens - cachedTokens,
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: { implicit: true }
+		};
+	}
+};
+/**
+* xAI Grok-specific caching adapter
+* Caching is automatic with optional conversation ID for cache affinity
+*/
+var XAICachingAdapter = class {
+	applyCaching(apiParams, strategy) {
+		return apiParams;
+	}
+	getHeaders(strategy) {
+		const headers = {};
+		if (strategy.conversationId) headers["x-grok-conv-id"] = strategy.conversationId;
+		return headers;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.prompt_tokens || 0;
+		const cachedTokens = usage.cached_prompt_tokens || 0;
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .65;
+		const estimatedLatencyReduction = cacheHitRate * .7;
+		return {
+			provider: ModelBackend.XAI,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: totalInputTokens - cachedTokens,
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: {
+				automatic: true,
+				conversationId: usage.x_grok_conv_id
+			}
+		};
+	}
+};
+/**
+* Moonshot (Kimi) context caching. Automatic, like xAI's: there is no parameter,
+* no header, and no explicit cache-creation call. A prompt only becomes cacheable
+* once it exceeds 256 tokens, so short turns legitimately report a 0% hit rate.
+* @see https://platform.kimi.ai/docs/guide/use-context-caching-feature-of-kimi-api
+*/
+var KimiCachingAdapter = class {
+	applyCaching(apiParams, _strategy) {
+		return apiParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.prompt_tokens || 0;
+		const details = usage.prompt_tokens_details;
+		const cachedTokens = usage.cached_tokens || details?.cached_tokens || 0;
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .9;
+		const estimatedLatencyReduction = cacheHitRate * .7;
+		return {
+			provider: ModelBackend.Kimi,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: Math.max(0, totalInputTokens - cachedTokens),
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: {
+				automatic: true,
+				minimumCacheablePromptTokens: 256
+			}
+		};
+	}
+};
+/**
+* Cached prompt tokens from a raw provider usage object, across every spelling in use:
+* OpenAI Chat Completions nests them under `prompt_tokens_details`, the OpenAI
+* Responses API under `input_tokens_details`, Moonshot publishes a flat
+* `cached_tokens` alongside the OpenAI-shaped nesting, and DeepSeek its own flat
+* `prompt_cache_hit_tokens`. Reading only one spelling silently bills every cache
+* hit on the other transports at the full input rate.
+*
+* DeepSeek's own spelling leads, because it is the number its invoice is computed
+* from; the OpenAI-shaped ones it also sends are the fallback for a proxy that
+* forwards only those.
+*/
+function cachedTokensFromUsage(usage) {
+	if (!usage) return 0;
+	const candidates = [
+		usage.prompt_cache_hit_tokens,
+		usage.cached_tokens,
+		usage.prompt_tokens_details?.cached_tokens,
+		usage.input_tokens_details?.cached_tokens
+	];
+	for (const value of candidates) if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	return 0;
+}
+/**
+* DeepSeek context caching. Automatic, like Moonshot's and xAI's: no parameter,
+* no header, no explicit cache-creation call. The adapter exists only to read
+* the counters back out.
+* @see https://api-docs.deepseek.com/guides/kv_cache
+*/
+var DeepSeekCachingAdapter = class {
+	applyCaching(apiParams, _strategy) {
+		return apiParams;
+	}
+	extractCacheStats(response, model) {
+		const usage = response.usage;
+		if (!usage) return void 0;
+		const totalInputTokens = usage.prompt_tokens || 0;
+		const cachedTokens = cachedTokensFromUsage(usage);
+		const cacheHitRate = totalInputTokens > 0 ? cachedTokens / totalInputTokens * 100 : 0;
+		const costSavingsPercent = cacheHitRate * .98;
+		const estimatedLatencyReduction = cacheHitRate * .7;
+		return {
+			provider: ModelBackend.DeepSeek,
+			model,
+			totalInputTokens,
+			cacheReadTokens: cachedTokens,
+			cacheWriteTokens: 0,
+			uncachedTokens: Math.max(0, totalInputTokens - cachedTokens),
+			cacheHitRate,
+			costSavingsPercent,
+			estimatedLatencyReduction,
+			providerMetadata: { automatic: true }
+		};
+	}
+};
+/**
+* No-op adapter for providers without caching support
+*/
+var NoOpCachingAdapter = class {
+	applyCaching(apiParams) {
+		return apiParams;
+	}
+	extractCacheStats() {}
+};
+ModelBackend.Anthropic, new AnthropicCachingAdapter(), ModelBackend.OpenAI, new OpenAICachingAdapter(), ModelBackend.Gemini, new GeminiCachingAdapter(), ModelBackend.Bedrock, new AnthropicCachingAdapter(), ModelBackend.XAI, new XAICachingAdapter(), ModelBackend.Kimi, new KimiCachingAdapter(), ModelBackend.DeepSeek, new DeepSeekCachingAdapter(), ModelBackend.Ollama, new NoOpCachingAdapter(), ModelBackend.BFL, new NoOpCachingAdapter(), ModelBackend.VoyageAI, new NoOpCachingAdapter(), ModelBackend.AWS, new NoOpCachingAdapter(), ModelBackend.LocalImage, new NoOpCachingAdapter();
+ChatModels.KIMI_K2_THINKING_BEDROCK, ChatModels.KIMI_K2_5_BEDROCK, ChatModels.DEEPSEEK_R1_BEDROCK, ChatModels.DEEPSEEK_FLASH, ChatModels.DEEPSEEK_V4_PRO;
+new Logger();
+ChatModels.CLAUDE_4_5_SONNET, ChatModels.CLAUDE_4_1_OPUS, ChatModels.CLAUDE_4_5_HAIKU, ChatModels.CLAUDE_4_5_OPUS, ChatModels.CLAUDE_4_6_SONNET, ChatModels.CLAUDE_4_6_OPUS;
+ChatModels.CLAUDE_4_5_SONNET_BEDROCK, ChatModels.CLAUDE_4_5_HAIKU_BEDROCK, ChatModels.CLAUDE_4_5_OPUS_BEDROCK, ChatModels.CLAUDE_4_6_SONNET_BEDROCK, ChatModels.CLAUDE_4_6_OPUS_BEDROCK;
+/** Ollama `done_reason` (chat/generate responses). */
+function normalizeOllamaDoneReason(reason) {
+	if (!reason) return void 0;
+	switch (reason) {
+		case "length": return "max_tokens";
+		default: return reason;
+	}
+}
+ChatModels.DEEPSEEK_FLASH, ChatModels.DEEPSEEK_V4_PRO;
+/** Type guard: does this message already carry OpenAI-style `tool_calls`? */
+function hasToolCalls(msg) {
+	return msg.role === "assistant" && "tool_calls" in msg;
+}
+function isToolUseBlock(block) {
+	return block.type === "tool_use";
+}
+function isToolResultBlock(block) {
+	return block.type === "tool_result";
+}
+function isTextBlock(block) {
+	return block.type === "text";
+}
+/**
+* Convert a single IMessage from B4M standard format to OpenAI-compatible format.
+* Returns an array because a single user message with multiple tool_result blocks
+* expands into multiple OpenAI 'tool' role messages.
+*
+* Messages already in OpenAI format (with `tool_calls` property) pass through unchanged.
+* Messages without tool_use/tool_result content blocks pass through unchanged.
+*/
+function convertMessageToOpenAIFormat(msg, options = {}) {
+	if (hasToolCalls(msg)) {
+		const reasoningContent = msg.reasoning_content;
+		return [{
+			role: "assistant",
+			content: null,
+			tool_calls: msg.tool_calls,
+			...options.preserveReasoningContent && typeof reasoningContent === "string" ? { reasoning_content: reasoningContent } : {}
+		}];
+	}
+	if (msg.role === "assistant" && Array.isArray(msg.content)) {
+		const contentBlocks = msg.content;
+		const toolUseBlocks = contentBlocks.filter(isToolUseBlock);
+		if (toolUseBlocks.length > 0) {
+			const textParts = contentBlocks.filter(isTextBlock).map((block) => block.text).filter(Boolean);
+			return [{
+				role: "assistant",
+				content: textParts.length > 0 ? textParts.join("\n") : null,
+				tool_calls: toolUseBlocks.map((block) => ({
+					id: block.id,
+					type: "function",
+					function: {
+						name: block.name,
+						arguments: JSON.stringify(block.input)
+					}
+				}))
+			}];
+		}
+	}
+	if (msg.role === "user" && Array.isArray(msg.content)) {
+		const toolResultBlocks = msg.content.filter(isToolResultBlock);
+		if (toolResultBlocks.length > 0) return toolResultBlocks.map((block) => ({
+			role: "tool",
+			content: block.content,
+			tool_call_id: block.tool_use_id
+		}));
+	}
+	if (msg.requiresTool !== void 0) {
+		const { requiresTool: _requiresTool, ...providerSafe } = msg;
+		return [providerSafe];
+	}
+	return [msg];
+}
+/**
+* Convert an array of IMessages from B4M standard format to OpenAI-compatible format.
+* Returns OpenAIFormattedMessage[] - callers targeting OpenAI SDK types should cast at the boundary.
+*/
+function convertMessagesToOpenAIFormat(messages, options = {}) {
+	return messages.flatMap((msg) => convertMessageToOpenAIFormat(msg, options));
+}
+ChatModels.KIMI_K3;
+ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED, ChatModels.KIMI_K2_6, ChatModels.KIMI_K2_5;
+ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED;
+ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED, ChatModels.KIMI_K2_6;
+ChatModels.KIMI_K3, ChatModels.KIMI_K2_7_CODE, ChatModels.KIMI_K2_7_CODE_HIGHSPEED, ChatModels.KIMI_K2_6, ChatModels.KIMI_K2_5;
+var OllamaBackend = class OllamaBackend {
+	_host;
+	_api;
+	_logger;
+	_clientHost;
+	_clientHeaders;
+	_agent;
+	currentModel = "";
+	constructor(host, logger) {
+		this._logger = logger ?? new Logger();
+		this._host = host ?? "http://localhost:11434";
+		const url = new URL(this._host);
+		const headers = {};
+		if (url.username && url.password) {
+			headers.Authorization = `Basic ${Buffer.from(`${url.username}:${url.password}`).toString("base64")}`;
+			url.username = "";
+			url.password = "";
+		}
+		this._agent = new Agent({
+			headersTimeout: 18e5,
+			bodyTimeout: 36e5
+		});
+		this._clientHost = url.toString();
+		this._clientHeaders = headers;
+		this._api = this.createClient();
+	}
+	/**
+	* Build an Ollama client. The `ollama` package takes no per-request
+	* AbortSignal (it only attaches an internal controller to streaming requests
+	* and exposes a client-wide abort()), so cancellation has to be bound into
+	* the fetch of a client made for that one request - hence the optional
+	* `signal`. The undici Agent is shared across clients so connection pooling
+	* and the raised timeouts survive.
+	*/
+	createClient(signal) {
+		const fetchWithTimeout = (input, init) => globalThis.fetch(input, {
+			...init,
+			dispatcher: this._agent,
+			...signal && { signal: init?.signal ? AbortSignal.any([init.signal, signal]) : signal }
+		});
+		return new Ollama({
+			host: this._clientHost,
+			headers: this._clientHeaders,
+			fetch: fetchWithTimeout
+		});
+	}
+	async getModelInfo() {
+		try {
+			const models = await this._api.list();
+			const isSelfHost = process.env.B4M_SELF_HOST === "true";
+			return await Promise.all(models.models.map(async (model) => {
+				const { capabilities, contextWindow: reportedContextWindow } = await this.getModelDetailsCached(model.name);
+				const contextWindow = OllamaBackend.effectiveContextWindow(reportedContextWindow);
+				return {
+					id: model.name,
+					type: "text",
+					name: model.name,
+					backend: ModelBackend.Ollama,
+					contextWindow,
+					max_tokens: OllamaBackend.advertisedOutputCap(contextWindow),
+					supportsImageVariation: false,
+					pricing: { [contextWindow]: {
+						input: 0,
+						output: 0
+					} },
+					freeToRun: true,
+					supportsVision: capabilities.includes("vision"),
+					supportsTools: capabilities.includes("tools"),
+					can_think: capabilities.includes("thinking"),
+					can_stream: true,
+					logoFile: "Ollama_Logo.svg",
+					rank: 1,
+					description: isSelfHost ? "Runs locally on your own hardware via Ollama. No API key required, and nothing leaves your machine. Performance and capabilities vary by model." : `This model is served from ${process.env.APP_NAME ? `${process.env.APP_NAME}'s` : "the platform"} Ollama servers using publicly available open-source models. Performance and capabilities vary by model.`
+				};
+			}));
+		} catch (error) {
+			let errorMessage = error instanceof Error ? error.message : String(error);
+			if (error instanceof Error && error.message.includes("503 Service Temporarily Unavailable")) errorMessage = "Ollama server is temporarily unavailable. Please try again later.";
+			this._logger.warn("[OllamaBackend] Error fetching model info from Ollama:", errorMessage);
+			return [];
+		}
+	}
+	/** Ollama's default when a model doesn't report a context length. */
+	static DEFAULT_CONTEXT_WINDOW = 8192;
+	/**
+	* Ceiling on the num_ctx we ask Ollama to allocate. Models advertise windows
+	* far larger than a dev box can hold in KV cache (262K on qwen3.5), so the
+	* useful value is the model's window capped at something affordable rather
+	* than the advertised maximum. Override with OLLAMA_MAX_NUM_CTX.
+	*/
+	static DEFAULT_MAX_NUM_CTX = 32768;
+	/**
+	* Output ceiling we advertise for a local model. Half of what we allocate, because advertising
+	* the whole window made the server's context - output - buffer negative and emptied the prompt.
+	*
+	* Halving alone is not enough at the bottom of the range: OLLAMA_MAX_NUM_CTX accepts any positive
+	* value, so an operator setting 2000 would leave exactly zero input budget for every local model
+	* at once. The second bound keeps input room for any window ABOVE the safety buffer.
+	*
+	* At or below the buffer nothing here can: a 500-token window yields a cap of 1 and still leaves
+	* 500 - 1 - 1000 negative. Clamping the window up to hide that would advertise more context than
+	* the model has, which is the misreporting this whole change removes, so the honest answer is
+	* that such a model cannot serve a chat prompt at all.
+	*/
+	static advertisedOutputCap(contextWindow) {
+		const halved = Math.floor(contextWindow / 2);
+		return Math.max(1, Math.min(halved, contextWindow - CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS - 1));
+	}
+	/** A model's reported window clamped to what we are willing to allocate. */
+	static effectiveContextWindow(reported) {
+		const configuredCap = Number(process.env.OLLAMA_MAX_NUM_CTX);
+		const cap = Number.isFinite(configuredCap) && configuredCap > 0 ? configuredCap : OllamaBackend.DEFAULT_MAX_NUM_CTX;
+		return Math.min(reported, cap);
+	}
+	/** Per-model /api/show results, so the tool-call recursion shows once, not per round. */
+	_modelDetails = /* @__PURE__ */ new Map();
+	getModelDetailsCached(model) {
+		let details = this._modelDetails.get(model);
+		if (!details) {
+			details = this.getModelDetails(model);
+			this._modelDetails.set(model, details);
+		}
+		return details;
+	}
+	/**
+	* Fetch a model's capabilities and context window from Ollama (/api/show).
+	* capabilities is e.g. ['completion', 'tools', 'vision']; the context length
+	* lives in model_info under "<architecture>.context_length" (e.g.
+	* "qwen2.context_length"). Returns safe defaults on any error so a transient
+	* show() failure degrades gracefully instead of dropping the whole list.
+	*/
+	async getModelDetails(model) {
+		try {
+			const info = await this._api.show({ model });
+			const capabilities = info.capabilities ?? [];
+			const raw = info.model_info;
+			const ctx = (raw instanceof Map ? Array.from(raw.entries()) : Object.entries(raw ?? {})).find(([k]) => k.endsWith(".context_length"))?.[1];
+			return {
+				capabilities,
+				contextWindow: typeof ctx === "number" && ctx > 0 ? ctx : OllamaBackend.DEFAULT_CONTEXT_WINDOW
+			};
+		} catch (error) {
+			this._logger.debug(`[OllamaBackend] Could not fetch details for ${model}:`, error);
+			return {
+				capabilities: [],
+				contextWindow: OllamaBackend.DEFAULT_CONTEXT_WINDOW
+			};
+		}
+	}
+	/**
+	* Ollama model parameters for a request. Everything here is silently dropped
+	* if the `options` object is omitted, which is why num_ctx matters most:
+	* without it the server falls back to its own 4096 default and truncates the
+	* prompt from the front, taking the tool block with it - so a large turn
+	* makes a tool-capable model answer that it has no tools. Sizing from the
+	* model's own reported window keeps that consistent with the context length
+	* the picker advertises.
+	*/
+	async buildModelOptions(model, options) {
+		const { contextWindow } = await this.getModelDetailsCached(model);
+		const numCtx = OllamaBackend.effectiveContextWindow(contextWindow);
+		return {
+			num_ctx: numCtx,
+			...typeof options.temperature === "number" && { temperature: options.temperature },
+			...typeof options.maxTokens === "number" && { num_predict: Math.min(options.maxTokens, numCtx) }
+		};
+	}
+	async complete(model, messages, options, callback) {
+		this.currentModel = model;
+		const toolCallCount = options._internal?.toolCallCount ?? 0;
+		const maxToolCalls = options._internal?.maxToolCalls ?? 10;
+		const priorToolsUsed = options._internal?.accumToolsUsed ?? [];
+		const priorInputTokens = options._internal?.accumInputTokens ?? 0;
+		const priorOutputTokens = options._internal?.accumOutputTokens ?? 0;
+		const toolsAvailable = (options.tools?.length ?? 0) > 0;
+		const offerTools = toolsAvailable && toolCallCount < maxToolCalls;
+		if (toolsAvailable && !offerTools) this._logger.warn(`[OllamaBackend] Max tool calls (${maxToolCalls}) reached; answering without tools.`);
+		const formattedTools = offerTools ? this.formatTools(options.tools ?? []) : [];
+		const baseRequest = {
+			model,
+			messages: this.buildMessages(offerTools ? messages : stripToolDependentMessages(messages)),
+			options: await this.buildModelOptions(model, options),
+			...formattedTools.length > 0 && { tools: formattedTools },
+			...typeof options.thinking?.enabled === "boolean" && { think: options.thinking.enabled }
+		};
+		try {
+			const round = await this.runChatRound(baseRequest, options, callback, { buffer: offerTools });
+			const inputTokens = priorInputTokens + (round.completionInfo.inputTokens ?? 0);
+			const outputTokens = priorOutputTokens + (round.completionInfo.outputTokens ?? 0);
+			let toolCalls = this.normalizeToolCalls(round.toolCalls);
+			if (toolCalls.length === 0 && offerTools) toolCalls = this.parseContentToolCall(round.content, options.tools ?? []);
+			const toolsUsed = [...priorToolsUsed, ...toolCalls.map((tc) => ({
+				name: tc.name,
+				arguments: tc.arguments,
+				id: tc.id
+			}))];
+			if (toolCalls.length === 0) {
+				await callback([offerTools ? round.content : ""], {
+					inputTokens,
+					outputTokens,
+					...toolsUsed.length > 0 && { toolsUsed },
+					...round.completionInfo.stopReason ? { stopReason: round.completionInfo.stopReason } : {}
+				});
+				return;
+			}
+			if (options.executeTools === false) {
+				await callback([""], {
+					inputTokens,
+					outputTokens,
+					toolsUsed
+				});
+				return;
+			}
+			const resolved = toolCalls.map((tc) => ({
+				tc,
+				toolFn: options.tools?.find((t) => t.toolSchema.name === tc.name)?.toolFn
+			})).filter((r) => !!r.toolFn);
+			const unknownCalls = toolCalls.filter((tc) => !options.tools?.some((t) => t.toolSchema.name === tc.name));
+			for (const tc of unknownCalls) this.pushToolMessages(messages, {
+				id: tc.id,
+				name: tc.name,
+				parameters: tc.arguments || "{}"
+			}, `Error: tool "${tc.name}" is not available. Do not call it again; answer directly or use a listed tool.`);
+			const outcomes = await executeToolsBatch(resolved.map(({ tc, toolFn }) => async () => {
+				let params = {};
+				try {
+					params = JSON.parse(tc.arguments || "{}");
+				} catch {}
+				this._logger.debug(`[OllamaBackend] Executing tool ${tc.name}`);
+				return String(await toolFn(params));
+			}), {
+				parallel: options.parallelToolExecution !== false,
+				maxConcurrency: options.maxParallelTools
+			});
+			const observations = [];
+			outcomes.forEach((outcome, i) => {
+				const { tc } = resolved[i];
+				const params = tc.arguments || "{}";
+				if (outcome.ok) {
+					observations[i] = outcome.result;
+					this.pushToolMessages(messages, {
+						id: tc.id,
+						name: tc.name,
+						parameters: params
+					}, outcome.result);
+				} else {
+					if (outcome.error instanceof PermissionDeniedError) throw outcome.error;
+					const errorMsg = `Error running ${tc.name}: ${outcome.error instanceof Error ? outcome.error.message : "Unknown error"}`;
+					observations[i] = errorMsg;
+					this.pushToolMessages(messages, {
+						id: tc.id,
+						name: tc.name,
+						parameters: params
+					}, errorMsg);
+				}
+			});
+			const executedToolsUsed = [...priorToolsUsed, ...resolved.map(({ tc }, i) => {
+				const entry = {
+					name: tc.name,
+					arguments: tc.arguments,
+					id: tc.id,
+					returnValue: truncateToolResult(String(observations[i])),
+					success: outcomes[i].ok
+				};
+				attachFullToolResult(entry, observations[i]);
+				return entry;
+			})];
+			if (options.abortSignal?.aborted) {
+				await callback([""], {
+					inputTokens,
+					outputTokens,
+					toolsUsed: executedToolsUsed
+				});
+				return;
+			}
+			await this.complete(model, messages, {
+				...options,
+				_internal: {
+					...options._internal,
+					toolCallCount: toolCallCount + 1,
+					accumToolsUsed: executedToolsUsed,
+					accumInputTokens: inputTokens,
+					accumOutputTokens: outputTokens
+				}
+			}, callback);
+		} catch (error) {
+			if (error instanceof Error && isUserInitiatedAbort(error, options.abortSignal)) this._logger.debug("[OllamaBackend] Ollama request cancelled by the caller");
+			else this._logger.error("[OllamaBackend] Error during Ollama API call:", error);
+			throw error;
+		}
+	}
+	/**
+	* Run a single Ollama chat turn. Streams text chunks to `callback` unless
+	* `buffer` is set (used for tool-eligible rounds, where the content is
+	* withheld until we know whether it is a tool call or the final answer).
+	* Returns the full text, any native tool calls, and token usage.
+	*/
+	async runChatRound(baseRequest, options, callback, { buffer }) {
+		const toolCalls = [];
+		let content = "";
+		let inputTokens = 0;
+		let outputTokens = 0;
+		let doneReason;
+		const api = options.abortSignal ? this.createClient(options.abortSignal) : this._api;
+		if (options.stream) {
+			const response = await api.chat({
+				...baseRequest,
+				stream: true
+			});
+			let startedThinking = false;
+			let stoppedThinking = false;
+			let thinkingFieldOpen = false;
+			const thinkEscaper = createThinkMarkerEscaper();
+			for await (const chunk of response) {
+				if (chunk.message.tool_calls?.length) toolCalls.push(...chunk.message.tool_calls);
+				let piece = "";
+				const thinkPiece = chunk.message.thinking || "";
+				if (thinkPiece) {
+					if (!thinkingFieldOpen) {
+						piece += "<think>";
+						thinkingFieldOpen = true;
+					}
+					piece += thinkEscaper.push(thinkPiece);
+				}
+				const contentPiece = chunk.message.content || "";
+				if (contentPiece) {
+					if (thinkingFieldOpen) {
+						piece += thinkEscaper.flush();
+						piece += "</think>";
+						thinkingFieldOpen = false;
+					}
+					startedThinking = startedThinking || contentPiece.includes("<think>");
+					stoppedThinking = stoppedThinking || contentPiece.includes("</think>");
+					piece += contentPiece;
+				}
+				if (chunk.done && (thinkingFieldOpen || startedThinking && !stoppedThinking)) {
+					if (thinkingFieldOpen) piece += thinkEscaper.flush();
+					piece = `${piece}</think>`;
+					thinkingFieldOpen = false;
+				}
+				content += piece;
+				inputTokens = Math.max(inputTokens, chunk.prompt_eval_count || 0);
+				outputTokens += chunk.eval_count || 0;
+				if (chunk.done_reason) doneReason = chunk.done_reason;
+				if (!buffer && piece) await callback([piece], {
+					inputTokens,
+					outputTokens
+				});
+			}
+		} else {
+			const response = await api.chat({
+				...baseRequest,
+				stream: false
+			});
+			if (response.message.tool_calls?.length) toolCalls.push(...response.message.tool_calls);
+			const think = response.message.thinking || "";
+			content = (think ? `<think>${escapeThinkMarkers(think)}</think>` : "") + (response.message.content || "");
+			inputTokens = response.prompt_eval_count || 0;
+			outputTokens = response.eval_count || 0;
+			doneReason = response.done_reason;
+			if (!buffer) await callback([content], {
+				inputTokens,
+				outputTokens
+			});
+		}
+		const stopReason = normalizeOllamaDoneReason(doneReason);
+		return {
+			content,
+			toolCalls,
+			completionInfo: {
+				inputTokens,
+				outputTokens,
+				...stopReason ? { stopReason } : {}
+			}
+		};
+	}
+	/**
+	* Normalize Ollama's native tool_calls into the shared NormalizedToolCall shape.
+	*
+	* Ids are real uuids, not a position-derived string. A prior version keyed ids off
+	* `accumulated-count + round-local-index`, but the accumulated count is measured AFTER
+	* hallucinated calls are filtered out while the round-local index is assigned BEFORE that
+	* filter runs, so the two can drift and mint the same id for two different real calls across
+	* rounds - replayableToolCalls dedupes by id and silently drops the later one. A uuid makes
+	* the whole collision class unrepresentable, matching how the other backends already mint ids.
+	*/
+	normalizeToolCalls(toolCalls) {
+		return toolCalls.map((tc) => ({
+			name: tc.function.name,
+			arguments: JSON.stringify(tc.function.arguments ?? {}),
+			id: `ollama-tool-${v4()}`
+		}));
+	}
+	/**
+	* Some smaller models emit tool calls as plain message content instead of
+	* using the native tool_calls field: a bare {"name":...,"arguments":{...}},
+	* the same wrapped in a ```json fence, or several such objects run together
+	* ({...} {...}). Recover every such object that names an available tool; if
+	* none match, the content is a normal answer.
+	*
+	* Guards against false positives: reasoning traces (<think>...</think>) are
+	* stripped first. The search source is a leading bare object (only when the
+	* reply STARTS with one) plus every fenced body - so a call wrapped in a fence
+	* after preamble prose is recovered, a bare call is not lost just because the
+	* reply also contains an unrelated fence, and JSON merely quoted mid-prose
+	* ("the math_evaluate tool takes {...}") is ignored. The seen-set dedupes any
+	* overlap between the two sources.
+	*
+	* Because any fenced block is a search source, a fenced EXAMPLE of a real
+	* (authorized) tool is also recovered and executed. This stays bounded to
+	* authorized tools (tryParseToolCallJson requires a name present in `tools`),
+	* so there is no privilege escalation - only a wider trigger surface.
+	*/
+	parseContentToolCall(content, tools) {
+		const withoutThink = content.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+		const fenced = this.extractFencedBlocks(withoutThink);
+		const source = [withoutThink.startsWith("{") ? withoutThink : "", ...fenced].join("\n");
+		if (!source.trim()) return [];
+		const calls = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const candidate of this.extractJsonObjects(source)) {
+			const call = this.tryParseToolCallJson(candidate, tools);
+			if (!call) continue;
+			const key = `${call.name}:${call.arguments}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			calls.push({
+				...call,
+				id: `ollama-content-tool-${v4()}`
+			});
+		}
+		return calls;
+	}
+	/**
+	* Return the body of every ```-fenced block, so a tool call the model wrapped
+	* in a fence after preamble prose can be isolated from the surrounding text.
+	*/
+	extractFencedBlocks(content) {
+		const blocks = [];
+		const fenceRegex = /```[^\n]*\n?([\s\S]*?)```/g;
+		let match;
+		while ((match = fenceRegex.exec(content)) !== null) blocks.push(match[1]);
+		return blocks;
+	}
+	/**
+	* Extract every balanced top-level {...} substring from arbitrary text. String
+	* contents are respected so braces inside JSON strings don't throw off nesting,
+	* and code fences / prose around the objects are ignored. Handles multiple
+	* objects run together, which is how some models emit parallel tool calls.
+	*/
+	extractJsonObjects(content) {
+		const objects = [];
+		let depth = 0;
+		let start = -1;
+		let inString = false;
+		let escaped = false;
+		for (let i = 0; i < content.length; i++) {
+			const ch = content[i];
+			if (inString) {
+				if (escaped) escaped = false;
+				else if (ch === "\\") escaped = true;
+				else if (ch === "\"") inString = false;
+				continue;
+			}
+			if (ch === "\"") inString = true;
+			else if (ch === "{") {
+				if (depth === 0) start = i;
+				depth++;
+			} else if (ch === "}" && depth > 0) {
+				depth--;
+				if (depth === 0 && start !== -1) {
+					objects.push(content.slice(start, i + 1));
+					start = -1;
+				}
+			}
+		}
+		return objects;
+	}
+	/**
+	* Parse one candidate string as a tool call naming a known tool. Models
+	* improvise the shape, so accept the common ones:
+	*   {"name":"t","arguments":{...}}          (Ollama/most)
+	*   {"function":"t","arguments":{...}}       (function-as-name)
+	*   {"function":{"name":"t","arguments":{}}} (OpenAI-style nested)
+	* plus "parameters"/"args" aliases for the arguments.
+	*/
+	tryParseToolCallJson(text, tools) {
+		const trimmed = text.trim();
+		if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			return null;
+		}
+		if (!parsed || typeof parsed !== "object") return null;
+		const obj = parsed;
+		let name;
+		let args;
+		const fn = obj.function;
+		if (fn && typeof fn === "object") {
+			name = fn.name;
+			args = fn.arguments;
+		} else name = obj.name ?? obj.function ?? obj.tool ?? obj.tool_name;
+		if (args === void 0) args = obj.arguments ?? obj.parameters ?? obj.args ?? {};
+		if (typeof name !== "string" || !tools.some((t) => t.toolSchema.name === name)) return null;
+		return {
+			name,
+			arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+		};
+	}
+	pushToolMessages(messages, tool, result, _thinkingBlocks) {
+		let argumentsObj;
+		try {
+			argumentsObj = JSON.parse(tool.parameters);
+		} catch {
+			argumentsObj = { _raw: tool.parameters };
+		}
+		messages.push({
+			content: "",
+			role: "assistant",
+			tool_calls: [{ function: {
+				name: tool.name,
+				arguments: argumentsObj
+			} }]
+		});
+		messages.push({
+			role: "tool",
+			tool_name: tool.name,
+			content: result
+		});
+	}
+	/**
+	* Convert ICompletionOptionTools into Ollama's Tool schema format.
+	*/
+	formatTools(tools) {
+		return tools.map((tool) => ({
+			type: "function",
+			function: {
+				...tool.toolSchema,
+				parameters: {
+					...tool.toolSchema.parameters,
+					required: tool.toolSchema.parameters.required ?? []
+				}
+			}
+		}));
+	}
+	/**
+	* Map IMessage[] to Ollama's Message[], preserving tool_calls for multi-turn
+	* tool conversations (added by pushToolMessages).
+	* First converts B4M standard format (tool_use/tool_result) to OpenAI-compatible
+	* format since Ollama uses the same tool_calls/role:tool convention.
+	*/
+	buildMessages(messages) {
+		return convertMessagesToOpenAIFormat(messages).map((msg) => {
+			const raw = msg;
+			const mapped = {
+				role: msg.role,
+				content: ""
+			};
+			if (Array.isArray(msg.content)) {
+				const texts = [];
+				const images = [];
+				for (const block of msg.content) if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+				else if (block.type === "image") if (block.source.type === "base64") images.push(block.source.data);
+				else this._logger.debug("[OllamaBackend] Dropping non-base64 image block; Ollama requires inline base64.");
+				else if (block.type === "image_url") {
+					const dataUrl = block.image_url.url.match(/^data:[^,]*;base64,(.+)$/s);
+					if (dataUrl) images.push(dataUrl[1]);
+					else this._logger.debug("[OllamaBackend] Dropping non-data image_url; Ollama requires inline base64.");
+				}
+				mapped.content = texts.join("\n");
+				if (images.length > 0) mapped.images = images;
+			} else mapped.content = msg.content != null ? String(msg.content) : "";
+			if (Array.isArray(raw.tool_calls)) mapped.tool_calls = raw.tool_calls;
+			if (typeof raw.tool_name === "string") mapped.tool_name = raw.tool_name;
+			return mapped;
+		});
+	}
+	async listModels() {
+		try {
+			this._logger.debug("[OllamaBackend] Listing models from Ollama");
+			const response = await this._api.list();
+			this._logger.debug("[OllamaBackend] Models listed from Ollama:", response.models);
+			return response.models;
+		} catch (error) {
+			this._logger.error("[OllamaBackend] Error listing models from Ollama:", error);
+			if (error.message?.includes("ECONNREFUSED") || error.message?.includes("Failed to fetch")) throw new Error(`Could not connect to Ollama. Please make sure it is running at ${this._host}`);
+			throw error;
+		}
+	}
+};
+ChatModels.O1_PREVIEW, ChatModels.O1_MINI, ChatModels.O1, ChatModels.O3_MINI, ChatModels.O3, ChatModels.O4_MINI;
+ChatModels.GPT5, ChatModels.GPT5_MINI, ChatModels.GPT5_NANO, ChatModels.GPT5_CHAT_LATEST;
+ChatModels.GPT5_1, ChatModels.GPT5_1_CHAT_LATEST;
+ChatModels.GPT5_2, ChatModels.GPT5_2_CHAT_LATEST;
+ChatModels.GPT5_4, ChatModels.GPT5_4_MINI, ChatModels.GPT5_4_NANO;
+ChatModels.GPT5_5;
+ChatModels.GPT5_6_SOL, ChatModels.GPT5_6_LUNA, ChatModels.GPT5_6_TERRA;
+ModelBackend.Bedrock, ModelBackend.AWS, ModelBackend.OpenAI, ModelBackend.Anthropic, ModelBackend.Gemini, ModelBackend.Ollama, ModelBackend.BFL, ModelBackend.XAI, ModelBackend.Kimi, ModelBackend.DeepSeek, ModelBackend.LocalImage, ModelBackend.VoyageAI;
+Object.values(ModelBackend);
+Object.entries(MODEL_INFO_FIELD_GROUP_OF);
+ModelBackend.Anthropic, ModelBackend.Gemini, ModelBackend.XAI, ModelBackend.Ollama, ModelBackend.BFL, ModelBackend.LocalImage, ModelBackend.AWS;
+ModelBackend.Ollama, ModelBackend.LocalImage;
+//#endregion
+//#region src/llm/NotifyingLlmBackend.ts
+/**
+* LLM backend wrapper that injects background agent notifications
+* into the message array before each completion call.
+*
+* When a background agent completes (or fails), the notification
+* appears as a system message so the main agent naturally sees it
+* in context - no polling required.
+*/
+var NotifyingLlmBackend = class {
+	constructor(inner, backgroundManager) {
+		this.inner = inner;
+		this.backgroundManager = backgroundManager;
+	}
+	get currentModel() {
+		return this.inner.currentModel;
+	}
+	set currentModel(model) {
+		this.inner.currentModel = model;
+	}
+	async complete(model, messages, options, callback) {
+		const notifications = this.backgroundManager.drainNotifications();
+		let effectiveMessages = messages;
+		if (notifications.length > 0) {
+			const notificationMessage = {
+				role: "user",
+				content: `[System Notification]\n\n${notifications.join("\n\n---\n\n")}\n\nPlease acknowledge these background agent results and incorporate them into your current work.`
+			};
+			effectiveMessages = [...messages, notificationMessage];
+		}
+		return this.inner.complete(model, effectiveMessages, options, callback);
+	}
+	pushToolMessages(messages, tool, result) {
+		return this.inner.pushToolMessages(messages, tool, result);
+	}
+	async getModelInfo() {
+		return this.inner.getModelInfo();
+	}
+};
+//#endregion
+//#region src/tools/deferredToolRegistry.ts
+/**
+* Registry of tool schemas that are NOT loaded into the model's initial tool
+* list. The model sees only the names (via the system prompt directory) and
+* must call the `tool_search` meta-tool to load schemas on demand.
+*
+* This mirrors Claude Code's deferred-tool pattern. The win is large for
+* heavy MCP integrations (e.g. 41 GitHub MCP tools at ~250-350 tokens of
+* JSONSchema each = ~10-15k tokens per turn that's now ~1-1.5k of names).
+*/
+var DeferredToolRegistry = class {
+	constructor() {
+		this.byName = /* @__PURE__ */ new Map();
+		this.directoryNames = [];
+	}
+	/** Replace registry contents with the supplied tools. Idempotent. */
+	register(tools) {
+		this.byName.clear();
+		for (const tool of tools) this.byName.set(tool.toolSchema.name, tool);
+		this.directoryNames = Object.freeze([...this.byName.keys()].sort());
+		logger.debug(`[DeferredToolRegistry] Registered ${tools.length} deferred tool(s)`);
+	}
+	clear() {
+		this.byName.clear();
+		this.directoryNames = Object.freeze([]);
+	}
+	size() {
+		return this.byName.size;
+	}
+	has(name) {
+		return this.byName.has(name);
+	}
+	get(name) {
+		return this.byName.get(name);
+	}
+	getAll() {
+		return Array.from(this.byName.values());
+	}
+	/** Return tools whose names appear in the supplied list, in input order. */
+	getByNames(names) {
+		const found = [];
+		for (const name of names) {
+			const tool = this.byName.get(name);
+			if (tool) found.push(tool);
+		}
+		return found;
+	}
+	/**
+	* Rank-search deferred tools by query terms. Name matches outrank
+	* description matches; exact substring on name wins ties.
+	*/
+	searchByKeywords(query, maxResults) {
+		const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+		if (terms.length === 0) return [];
+		const scored = [];
+		for (const tool of this.byName.values()) {
+			const name = tool.toolSchema.name.toLowerCase();
+			const desc = (tool.toolSchema.description || "").toLowerCase();
+			let score = 0;
+			for (const term of terms) {
+				if (name.includes(term)) score += 10;
+				if (desc.includes(term)) score += 1;
+			}
+			if (score > 0) scored.push({
+				tool,
+				score
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		return scored.slice(0, maxResults).map((s) => s.tool);
+	}
+	/**
+	* Directory entries rendered into the cache-stamped system-prompt reminder.
+	* Returns the frozen snapshot captured at `register()`, NOT live `byName`
+	* keys, so loading a tool mid-session can never change a byte of the cached
+	* system block (issue #213). A loaded tool remaining listed here is
+	* harmless: re-selecting it via `tool_search` is an idempotent no-op.
+	*/
+	getDirectoryNames() {
+		return [...this.directoryNames];
+	}
+};
+const deferredToolRegistry = new DeferredToolRegistry();
+//#endregion
+//#region src/tools/toolSearchTool.ts
+/**
+* Default number of tools returned for a keyword search. Matches Claude
+* Code's ToolSearch convention. 5 keeps the response payload small while
+* surfacing enough alternatives for the model to refine its query.
+*/
+const DEFAULT_MAX_RESULTS = 5;
+/**
+* Runtime validation for tool_search params. The LLM produces these
+* values, so we validate at this boundary rather than trusting the
+* shape. Coerces `max_results` from string->number for models that emit
+* numeric-looking strings.
+*/
+const ToolSearchParamsSchema = z$1.object({
+	query: z$1.string().min(1, "query must be a non-empty string"),
+	max_results: z$1.coerce.number().int().min(1).max(20).optional()
+});
+/**
+* Parse the query string. Two forms:
+*   - `select:name1,name2,...` - exact-name selection
+*   - free text - keyword search across name + description
+*/
+function parseQuery(query) {
+	const trimmed = query.trim();
+	const selectMatch = trimmed.match(/^select:(.+)$/i);
+	if (selectMatch) return {
+		mode: "select",
+		names: selectMatch[1].split(",").map((n) => n.trim()).filter((n) => n.length > 0)
+	};
+	return {
+		mode: "search",
+		text: trimmed
+	};
+}
+/**
+* Format the loaded-tools response. Mirrors Claude Code's convention:
+* one <function>{...}</function> line per matched tool. The model has
+* already seen this format in its tool-registration system messages, so
+* it parses without additional explanation.
+*
+* Note: the schemas are *also* injected into context.tools by the caller,
+* so on the next iteration the model gets them as native tool definitions.
+* The text response here is for in-turn awareness and audit trail.
+*/
+function renderToolsBlock(tools) {
+	if (tools.length === 0) return "";
+	return `<functions>\n${tools.map((tool) => {
+		const schema = {
+			description: tool.toolSchema.description,
+			name: tool.toolSchema.name,
+			parameters: tool.toolSchema.parameters
+		};
+		return `<function>${JSON.stringify(schema)}</function>`;
+	}).join("\n")}\n</functions>`;
+}
+/**
+* Build the tool_search meta-tool. The returned tool has a closure over
+* the supplied `toolListAccessor`, which it uses to push newly-resolved
+* tool schemas into the live agent context.
+*
+* Idempotent: re-loading a tool that's already in the context is a no-op.
+*/
+function createToolSearchTool(toolListAccessor) {
+	return {
+		toolSchema: {
+			name: "tool_search",
+			description: "Fetches full schema definitions for deferred tools so they can be called. Deferred tools appear by name only in a system reminder; their parameter schemas are NOT loaded by default. Use this tool to load schemas on demand. Query forms: 'select:name1,name2' for exact selection, or free-text keywords to search by name and description. Once a tool's schema is returned, it becomes callable in subsequent turns.",
+			parameters: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						description: "Either 'select:<comma-separated names>' to fetch specific tools, or free-text keywords (e.g. 'github pull request') to rank-search deferred tools."
+					},
+					max_results: {
+						type: "number",
+						description: `Maximum number of tools to return for keyword search. Defaults to ${DEFAULT_MAX_RESULTS}. Ignored for 'select:' queries.`
+					}
+				},
+				required: ["query"]
+			}
+		},
+		toolFn: async (params) => {
+			const parsedParams = ToolSearchParamsSchema.safeParse(params ?? {});
+			if (!parsedParams.success) {
+				const issue = parsedParams.error.issues[0];
+				return `tool_search: invalid parameters — ${issue.path.join(".") || "params"}: ${issue.message}`;
+			}
+			const { query, max_results } = parsedParams.data;
+			const parsed = parseQuery(query);
+			let matched;
+			let unmatched = [];
+			if (parsed.mode === "select") {
+				matched = deferredToolRegistry.getByNames(parsed.names);
+				const foundNames = new Set(matched.map((t) => t.toolSchema.name));
+				unmatched = parsed.names.filter((n) => !foundNames.has(n));
+			} else {
+				const max = max_results ?? DEFAULT_MAX_RESULTS;
+				matched = deferredToolRegistry.searchByKeywords(parsed.text, max);
+			}
+			if (matched.length === 0) return parsed.mode === "select" ? `tool_search: no deferred tools matched ${parsed.names.join(", ")}. Use a free-text query to search.` : `tool_search: no deferred tools matched query "${parsed.text}".`;
+			const liveTools = toolListAccessor();
+			const liveNames = new Set(liveTools.map((t) => t.toolSchema.name));
+			let added = 0;
+			for (const tool of matched) if (!liveNames.has(tool.toolSchema.name)) {
+				liveTools.push(tool);
+				added++;
+			}
+			logger.debug(`[tool_search] query="${query}" matched=${matched.length} added=${added} alreadyLoaded=${matched.length - added}`);
+			const block = renderToolsBlock(matched);
+			return `${`Loaded ${added} new tool schema(s)${added < matched.length ? ` (${matched.length - added} already loaded)` : ""}. These are now callable in your next message.${unmatched.length > 0 ? `\n\nNot found: ${unmatched.join(", ")}` : ""}`}\n\n${block}`;
+		}
+	};
+}
+//#endregion
+//#region src/llm/MultiLlmBackend.ts
+/**
+* Routes completions between B4M server and a local Ollama instance
+* based on the selected model's backend type.
+*/
+var MultiLlmBackend = class {
+	constructor(serverBackend, ollamaBackend, serverModels, ollamaModels, initialModel) {
+		this.serverBackend = serverBackend;
+		this.ollamaBackend = ollamaBackend;
+		this.serverModels = serverModels;
+		this.ollamaModels = ollamaModels;
+		this.currentModel = initialModel;
+		this.ollamaModelIds = new Set(ollamaModels.map((m) => m.id));
+	}
+	get activeBackend() {
+		return this.ollamaModelIds.has(this.currentModel) ? this.ollamaBackend : this.serverBackend;
+	}
+	async complete(model, messages, options, callback) {
+		return (this.ollamaModelIds.has(model) ? this.ollamaBackend : this.serverBackend).complete(model, messages, options, callback);
+	}
+	pushToolMessages(messages, tool, result, thinkingBlocks) {
+		this.activeBackend.pushToolMessages(messages, tool, result, thinkingBlocks);
+	}
+	async getModelInfo() {
+		return [...this.serverModels, ...this.ollamaModels];
+	}
+};
+//#endregion
+//#region src/ws/WebSocketConnectionManager.ts
+const useWsPolyfill = typeof globalThis.WebSocket === "undefined";
+const WS = useWsPolyfill ? WebSocket : globalThis.WebSocket;
+/**
+* Manages a persistent WebSocket connection for CLI <-> server communication.
+* Handles heartbeat, reconnection, and message routing by requestId.
+*
+* Uses Node.js built-in WebSocket (Node 22+) with `ws` package fallback for Node 20.
+*/
+var WebSocketConnectionManager = class {
+	/**
+	* @param verifySession - Optional. Called when a connect ATTEMPT fails (the socket closed
+	*   without ever opening) - exactly the signal an auth-rejected handshake produces. Omit to
+	*   preserve the old always-retry-forever behavior.
+	*/
+	constructor(wsUrl, getToken, verifySession) {
+		this.ws = null;
+		this.heartbeatInterval = null;
+		this.reconnectAttempts = 0;
+		this.maxReconnectDelay = 3e4;
+		this.handlers = /* @__PURE__ */ new Map();
+		this.actionHandlers = /* @__PURE__ */ new Map();
+		this.disconnectHandlers = /* @__PURE__ */ new Set();
+		this.revokedHandlers = /* @__PURE__ */ new Set();
+		this.reconnectTimer = null;
+		this.connected = false;
+		this.connecting = false;
+		this.closed = false;
+		this.openedThisAttempt = false;
+		this.verifyingSession = false;
+		this.revoked = false;
+		this.wsUrl = wsUrl;
+		this.getToken = getToken;
+		this.verifySession = verifySession;
+	}
+	/**
+	* Connect to the WebSocket server.
+	* Resolves when connection is established, rejects on failure.
+	*/
+	async connect() {
+		if (this.connected || this.connecting) return;
+		this.connecting = true;
+		this.openedThisAttempt = false;
+		const token = await this.getToken();
+		if (!token) {
+			this.connecting = false;
+			throw new Error("No access token available for WebSocket connection");
+		}
+		return new Promise((resolve, reject) => {
+			logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
+			if (useWsPolyfill) this.ws = new WebSocket(this.wsUrl, { headers: { "Sec-WebSocket-Protocol": `access_token.${token}` } });
+			else this.ws = new WS(this.wsUrl, [`access_token.${token}`]);
+			this.ws.onopen = () => {
+				logger.debug("[WS] Connected");
+				this.connected = true;
+				this.connecting = false;
+				this.openedThisAttempt = true;
+				this.reconnectAttempts = 0;
+				this.startHeartbeat();
+				resolve();
+			};
+			this.ws.onmessage = (event) => {
+				try {
+					const data = typeof event.data === "string" ? event.data : event.data.toString();
+					const message = JSON.parse(data);
+					const requestId = message.requestId;
+					if (requestId && this.handlers.has(requestId)) this.handlers.get(requestId)(message);
+					else {
+						const action = message.action;
+						if (action && this.actionHandlers.has(action)) this.actionHandlers.get(action)(message);
+						else logger.debug(`[WS] Unhandled message: ${action || "unknown"}`);
+					}
+				} catch (err) {
+					logger.debug(`[WS] Failed to parse message: ${err}`);
+				}
+			};
+			this.ws.onclose = () => {
+				logger.debug("[WS] Connection closed");
+				const openedThisAttempt = this.openedThisAttempt;
+				this.cleanup();
+				this.notifyDisconnect();
+				if (this.closed || this.revoked) return;
+				if (openedThisAttempt || !this.verifySession) {
+					this.scheduleReconnect();
+					return;
+				}
+				this.verifyThenReconnect();
+			};
+			this.ws.onerror = (err) => {
+				const detail = err.error?.message || String(err);
+				logger.debug(`[WS] Error: ${detail}`);
+				if (this.connecting) {
+					this.connecting = false;
+					this.connected = false;
+					reject(/* @__PURE__ */ new Error(`WebSocket connection failed: ${detail}`));
+				}
+			};
+		});
+	}
+	/** Whether the connection is currently established */
+	get isConnected() {
+		return this.connected;
+	}
+	/**
+	* Send a JSON message over the WebSocket connection.
+	*/
+	send(data) {
+		if (!this.ws || this.ws.readyState !== WS.OPEN) throw new Error("WebSocket is not connected");
+		const payload = JSON.stringify(data);
+		const sizeKB = (payload.length / 1024).toFixed(1);
+		logger.debug(`[WS] Sending ${sizeKB} KB (action: ${data.action})`);
+		if (payload.length > 32e3) logger.warn(`[WS] Payload ${sizeKB} KB exceeds API Gateway 32 KB frame limit — connection will be closed`);
+		this.ws.send(payload);
+	}
+	/**
+	* Register a handler for messages matching a specific requestId.
+	*/
+	onRequest(requestId, handler) {
+		this.handlers.set(requestId, handler);
+	}
+	/**
+	* Remove a handler for a specific requestId.
+	*/
+	offRequest(requestId) {
+		this.handlers.delete(requestId);
+	}
+	/**
+	* Register a handler for messages matching a specific action type.
+	* Used for server-pushed commands like keep_command.
+	*/
+	onAction(action, handler) {
+		this.actionHandlers.set(action, handler);
+	}
+	/**
+	* Remove a handler for a specific action type.
+	*/
+	offAction(action) {
+		this.actionHandlers.delete(action);
+	}
+	/**
+	* Register a handler that fires when the connection drops.
+	*/
+	onDisconnect(handler) {
+		this.disconnectHandlers.add(handler);
+	}
+	/**
+	* Remove a disconnect handler.
+	*/
+	offDisconnect(handler) {
+		this.disconnectHandlers.delete(handler);
+	}
+	/**
+	* Register a handler that fires once the session is confirmed revoked (verifySession
+	* returned false) and the reconnect loop has permanently stopped.
+	*/
+	onRevoked(handler) {
+		this.revokedHandlers.add(handler);
+	}
+	/**
+	* Remove a revoked handler.
+	*/
+	offRevoked(handler) {
+		this.revokedHandlers.delete(handler);
+	}
+	/** Whether the session has been confirmed revoked (reconnecting has permanently stopped). */
+	get isRevoked() {
+		return this.revoked;
+	}
+	/**
+	* Close the connection and stop all heartbeat/reconnect logic.
+	*/
+	disconnect() {
+		this.closed = true;
+		this.cleanup();
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		this.handlers.clear();
+		this.actionHandlers.clear();
+		this.disconnectHandlers.clear();
+		this.revokedHandlers.clear();
+	}
+	startHeartbeat() {
+		this.stopHeartbeat();
+		this.heartbeatInterval = setInterval(() => {
+			if (this.ws && this.ws.readyState === WS.OPEN) {
+				this.ws.send(JSON.stringify({ action: "heartbeat" }));
+				logger.debug("[WS] Heartbeat sent");
+			}
+		}, 3e5);
+	}
+	stopHeartbeat() {
+		if (this.heartbeatInterval) {
+			clearInterval(this.heartbeatInterval);
+			this.heartbeatInterval = null;
+		}
+	}
+	cleanup() {
+		this.connected = false;
+		this.connecting = false;
+		this.stopHeartbeat();
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+	}
+	notifyDisconnect() {
+		for (const handler of this.disconnectHandlers) try {
+			handler();
+		} catch {}
+	}
+	notifyRevoked() {
+		for (const handler of this.revokedHandlers) try {
+			handler();
+		} catch {}
+	}
+	/**
+	* Called when a connect attempt fails to open at all - the signal a 401 handshake refusal
+	* produces. Verifies the session via the injected `verifySession` (single-flighted) before
+	* deciding whether to keep retrying. A verification that itself errors (network blip, 5xx)
+	* is treated as transient - only an explicit `false` result stops the loop.
+	*/
+	async verifyThenReconnect() {
+		if (this.verifyingSession) return;
+		this.verifyingSession = true;
+		try {
+			if (!await this.verifySession()) {
+				logger.debug("[WS] Session verification failed - session revoked, stopping reconnect");
+				this.revoked = true;
+				this.notifyRevoked();
+				return;
+			}
+		} catch (err) {
+			logger.debug(`[WS] Session verification errored - treating as transient: ${err}`);
+		} finally {
+			this.verifyingSession = false;
+		}
+		this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		if (this.closed || this.revoked) return;
+		this.reconnectAttempts++;
+		const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+		logger.debug(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+		this.reconnectTimer = setTimeout(async () => {
+			this.reconnectTimer = null;
+			if (this.closed) return;
+			try {
+				await this.connect();
+			} catch {
+				logger.debug("[WS] Reconnection failed");
+			}
+		}, delay);
+	}
+};
+//#endregion
+//#region src/bootstrap/buildLlmBackend.ts
+/** Production wiring: real transport classes + the ToolRouter singleton. */
+const defaultLlmBackendDeps = {
+	connectWebSocket: async (wsUrl, tokenGetter, verifySession) => {
+		const ws = new WebSocketConnectionManager(wsUrl, tokenGetter, verifySession);
+		ws.onRevoked(() => {
+			logger.warn("Session revoked - run `b4m login` again. WebSocket reconnect stopped.");
+		});
+		try {
+			await ws.connect();
+		} catch (err) {
+			ws.disconnect();
+			throw err;
+		}
+		return ws;
+	},
+	clearWebSocketToolExecutor: () => setWebSocketToolExecutor(null),
+	createServerBackend: (opts) => new ServerLlmBackend(opts),
+	createOllamaBackend: (host) => new OllamaBackend(host, {
+		debug: (...args) => logger.debug(args.map(String).join(" ")),
+		info: (...args) => logger.info(args.map(String).join(" ")),
+		warn: (...args) => logger.warn(args.map(String).join(" ")),
+		error: (...args) => logger.error(args.map(String).join(" "))
+	}),
+	createMultiBackend: (server, ollama, serverModels, ollamaModels, defaultModel) => new MultiLlmBackend(server, ollama, serverModels, ollamaModels, defaultModel)
+};
+/**
+* True when some enabled feature module consumes realtime server events. Only
+* Tavern does today (TavernModule.registerWsHandlers -> TavernActivityStream);
+* keep this in sync with the module registration in index.tsx. Everything else
+* runs socket-free, so the common path never opens a WebSocket.
+*/
+function needsFeatureEventSocket(config) {
+	return config.features?.tavern === true;
+}
+/**
+* Connect the events-only socket that feature modules register handlers on.
+* Returns null when it isn't needed, isn't advertised, or won't connect - a
+* feature's live updates degrading is never a reason to fail startup, since
+* completions no longer depend on this socket at all.
+*/
+async function connectFeatureEventSocket(config, websocketUrl, deps, auth) {
+	if (!needsFeatureEventSocket(config)) return null;
+	if (!websocketUrl) {
+		logger.debug("[WS] No websocketUrl in server config - feature live updates disabled");
+		return null;
+	}
+	try {
+		return await deps.connectWebSocket(websocketUrl, auth.tokenGetter, auth.verifySession);
+	} catch (err) {
+		logger.warn(`Realtime socket unavailable - live feature updates are disabled: ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+/**
+* Resolve the model to use from the available list: the requested default if
+* present, otherwise the first available model. Pure - exported for testing.
+*/
+function resolveModelInfo(models, defaultModel) {
+	return models.find((m) => m.id === defaultModel) || models[0];
+}
+/**
+* Build the LLM backend: HTTP+SSE transport (ServerLlmBackend), optional Ollama
+* multiplexing. Resolves the default model and pins it on the backend.
+*
+* The WebSocket COMPLETION transport was removed - completions always use SSE,
+* because relays that emit the generic `streamed_chat_completion` action drop
+* every CLI chunk. The socket itself is still connected, but only when a
+* WS-consuming feature module is enabled, and only to carry that module's events
+* (see `wsManager`); Keep relay and WS server-side tool execution stay off.
+*
+* Pure bootstrap seam: no React hooks, no Zustand state.
+*/
+async function buildLlmBackend(input, deps = defaultLlmBackendDeps) {
+	const { config, apiClient, startupLog, tokenGetter } = input;
+	const sse = await createSseBackend({
+		apiClient,
+		model: config.defaultModel
+	}, {
+		createServerBackend: deps.createServerBackend,
+		clearWebSocketToolExecutor: deps.clearWebSocketToolExecutor
+	});
+	let llm = sse.llm;
+	const wsManager = await connectFeatureEventSocket(config, sse.serverConfig.websocketUrl, deps, {
+		tokenGetter,
+		verifySession: () => apiClient.checkSessionValid()
+	});
+	const ollamaHost = input.ollamaHost ?? process.env.B4M_OLLAMA_HOST;
+	let models;
+	if (ollamaHost) {
+		const ollamaBackend = deps.createOllamaBackend(ollamaHost);
+		const [serverModels, ollamaModels] = await Promise.all([llm.getModelInfo(), ollamaBackend.getModelInfo()]);
+		if (serverModels.length === 0 && ollamaModels.length === 0) throw new Error(`No models available from server or Ollama at ${ollamaHost}.\nPull a model: ollama pull qwen3.5`);
+		if (ollamaModels.length === 0) startupLog.push(`⚠️  No models found in Ollama at ${ollamaHost}. Pull one with: ollama pull qwen3.5`);
+		const serverBackend = llm;
+		llm = deps.createMultiBackend(serverBackend, ollamaBackend, serverModels, ollamaModels, config.defaultModel);
+		models = await llm.getModelInfo();
+		startupLog.push(`🦙 Self-hosted Ollama: ${ollamaModels.length} model(s) added to picker`);
+	} else {
+		models = await llm.getModelInfo();
+		if (models.length === 0) throw new Error("No models available from server.");
+	}
+	logger.debug(`📋 Available models: ${models.map((m) => m.id).join(", ")}`);
+	const modelInfo = resolveModelInfo(models, config.defaultModel);
+	if (modelInfo.id !== config.defaultModel) {
+		logger.warn(`⚠️  Requested model '${config.defaultModel}' not available`);
+		logger.warn(`🤖 Using fallback model: ${modelInfo.id}`);
+	}
+	llm.currentModel = modelInfo.id;
+	return {
+		llm,
+		wsManager,
+		models,
+		modelInfo
+	};
+}
+//#endregion
+//#region src/bootstrap/buildSupportingStores.ts
+/**
+* Build the supporting stores and orchestration the agent needs: CLI tools
+* (permission-wrapped + server-routed), MCP manager, agent store, context
+* files, the deferred-tool registry partition, the subagent orchestrator, and
+* the background-agent manager.
+*
+* Pure bootstrap seam: no React hooks, no Zustand state. React-owned values
+* (permission/user-question prompt functions, the agent context, and the
+* background-agent status callbacks) are passed in. Tool *assembly* that weaves
+* the React workflow-store refs (decision/blocker/review-gate tools) stays in
+* the shell; this module returns only the agent-construction materials.
+*/
+async function buildSupportingStores(input) {
+	const { config, llm, modelId, permissionManager, apiClient, configStore, customCommandStore, checkpointStore, sandboxOrchestrator, additionalDirectories, agentContext, promptFn, userQuestionFn, startupLog, silentLogger, onBackgroundStatusChange, onGroupCompletion, onSubagentUsage } = input;
+	const { tools: b4mTools } = await generateCliTools(config.userId, llm, modelId, permissionManager, promptFn, agentContext, configStore, apiClient, void 0, userQuestionFn, checkpointStore, sandboxOrchestrator, additionalDirectories);
+	const mcpManager = new McpManager(config);
+	const builtinAgentsDir = new URL("../agents/defaults/", import.meta.url).pathname;
+	const agentStore = buildProjectAgentStore(builtinAgentsDir, configStore);
+	const [, , contextResult] = await Promise.all([
+		mcpManager.initialize(),
+		agentStore.loadAgents(),
+		loadProjectContext(configStore)
+	]);
+	const mcpTools = wrapTools(mcpManager.getTools(), {
+		permissionManager,
+		showPermissionPrompt: promptFn,
+		agentContext,
+		configStore,
+		apiClient,
+		sandboxOrchestrator,
+		allowedDirectories: additionalDirectories
+	});
+	const deferredB4mToolNames = /* @__PURE__ */ new Set([
+		"math_evaluate",
+		"dice_roll",
+		"current_datetime",
+		"recent_changes",
+		"prompt_enhancement"
+	]);
+	const deferredB4mTools = b4mTools.filter((t) => deferredB4mToolNames.has(t.toolSchema.name));
+	const loadedB4mTools = b4mTools.filter((t) => !deferredB4mToolNames.has(t.toolSchema.name));
+	deferredToolRegistry.register([...mcpTools, ...deferredB4mTools]);
+	if (mcpTools.length > 0) {
+		const serverSummaries = mcpManager.getToolCount().map((s) => `${s.serverName} (${s.count})`).join(", ");
+		startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M + ${mcpTools.length} MCP tool(s, ${deferredB4mTools.length + mcpTools.length} deferred): ${serverSummaries}`);
+	} else {
+		const suffix = deferredB4mTools.length > 0 ? ` (${deferredB4mTools.length} deferred)` : "";
+		startupLog.push(`🛠️ Loaded ${loadedB4mTools.length} B4M tool(s)${suffix}, no MCP tools`);
+	}
+	const agentSummary = agentStore.getSummary();
+	startupLog.push(`🤖 Loaded ${agentSummary.total} agent(s): ${agentSummary.builtin} built-in, ${agentSummary.global} global, ${agentSummary.project} project`);
+	const historyStore = new AgentHistoryStore(config.preferences.subagentHistoryTtlMs ?? 36e5);
+	const orchestrator = new SubagentOrchestrator({
+		userId: config.userId,
+		llm,
+		logger: silentLogger,
+		permissionManager,
+		showPermissionPrompt: promptFn,
+		configStore,
+		apiClient,
+		agentStore,
+		customCommandStore,
+		enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
+		showUserQuestion: userQuestionFn,
+		checkpointStore,
+		onSubagentUsage,
+		historyStore,
+		sandboxOrchestrator,
+		additionalDirectories
+	});
+	const backgroundManager = new BackgroundAgentManager(orchestrator);
+	backgroundManager.setOnStatusChange(onBackgroundStatusChange);
+	backgroundManager.setOnGroupCompletion(onGroupCompletion);
+	return {
+		mcpManager,
+		agentStore,
+		contextResult,
+		mcpTools,
+		loadedB4mTools,
+		deferredB4mTools,
+		orchestrator,
+		backgroundManager,
+		historyStore
+	};
+}
+//#endregion
+//#region src/bootstrap/buildAgent.ts
+/**
+* Construct the main ReAct agent with the system prompt selected by config
+* variant, wire the tool_search closure to the agent's live tools array, and
+* record the agent in the shared observation context.
+*
+* Pure bootstrap seam: no React hooks, no Zustand state. The interaction-mode
+* subscription (`useCliStore.subscribe`) stays in the shell and uses the
+* returned `buildPromptForMode`. Ordering is load-bearing: agent built ->
+* agentToolsRef wired -> agentContext.currentAgent set, all here, before the
+* shell registers the subscription (which guards on currentAgent === agent).
+*/
+function buildAgent(input) {
+	const { config, modelId, notifyingLlm, allTools, agentContext, agentToolsRef, silentLogger, sessionId, initialInteractionMode, contextContent, agentStore, customCommandStore, enableSkillTool, additionalDirectories, featureModulePrompts } = input;
+	const promptVariant = config.preferences.promptVariant ?? "current";
+	const buildPromptForMode = (mode) => buildSystemPrompt(promptVariant, {
+		contextContent,
+		agentStore,
+		customCommands: customCommandStore.getModelReachableCommands(),
+		enableSkillTool,
+		enableDynamicAgentCreation: config.preferences.enableDynamicAgentCreation === true,
+		additionalDirectories,
+		featureModulePrompts: featureModulePrompts || void 0,
+		planModeFilePath: mode === "plan" ? getPlanModeFilePath(sessionId) : void 0,
+		appendSystemPrompt: process.env.B4M_APPEND_SYSTEM_PROMPT,
+		deferredToolNames: deferredToolRegistry.getDirectoryNames()
+	});
+	const cliSystemPrompt = buildPromptForMode(initialInteractionMode);
+	const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
+	const agent = new ReActAgent({
+		userId: config.userId,
+		logger: silentLogger,
+		llm: notifyingLlm,
+		model: modelId,
+		tools: allTools,
+		maxIterations,
+		maxTokens: config.preferences.maxTokens,
+		temperature: config.preferences.temperature,
+		systemPrompt: cliSystemPrompt,
+		unknownToolResolver: async (toolName) => deferredToolRegistry.get(toolName) ?? null
+	});
+	agentToolsRef.current = agent.getTools();
+	agentContext.currentAgent = agent;
+	return {
+		agent,
+		buildPromptForMode
+	};
+}
+//#endregion
+export { deferredToolRegistry as a, createToolSearchTool as i, buildSupportingStores as n, NotifyingLlmBackend as o, buildLlmBackend as r, buildAgent as t };