goatchain 0.0.1

package/dist/index.js

@@ -0,0 +1,4795 @@
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import OpenAI from "openai";
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+
+//#region src/agent/checkpointMiddleware.ts
+/**
+* Convert AgentLoopState to AgentLoopCheckpoint
+*/
+function toLoopCheckpoint(state, options) {
+	let phase = options?.phase;
+	if (!phase) if (!state.shouldContinue) phase = "completed";
+	else if (state.pendingToolCalls.length > 0) phase = "tool_execution";
+	else phase = "llm_call";
+	let status = options?.status;
+	if (!status) if (phase === "completed") status = `Completed: ${state.stopReason ?? "unknown"}`;
+	else if (phase === "tool_execution") status = `Executing tools: ${state.pendingToolCalls.map((tc) => tc.toolCall.function.name).join(", ")}`;
+	else if (phase === "approval_pending") status = "Waiting for user approval";
+	else status = `Iteration ${state.iteration}: Calling LLM`;
+	return {
+		sessionId: state.sessionId,
+		agentId: state.agentId,
+		agentName: options?.agentName,
+		iteration: state.iteration,
+		phase,
+		status,
+		modelConfig: options?.modelConfig,
+		requestParams: options?.requestParams,
+		messages: [...state.messages],
+		pendingToolCalls: state.pendingToolCalls.map((tc) => ({
+			toolCall: { ...tc.toolCall },
+			result: tc.result,
+			isError: tc.isError
+		})),
+		currentResponse: state.currentResponse,
+		currentThinking: state.currentThinking,
+		shouldContinue: state.shouldContinue,
+		stopReason: state.stopReason,
+		lastModelStopReason: state.lastModelStopReason,
+		usage: { ...state.usage },
+		metadata: { ...state.metadata },
+		savedAt: Date.now()
+	};
+}
+/**
+* Restore AgentLoopState from AgentLoopCheckpoint
+*
+* Note: agentName, phase, and status are display-only fields and are not
+* part of AgentLoopState. They will be recalculated when a new checkpoint is saved.
+*/
+function fromLoopCheckpoint(checkpoint) {
+	return {
+		sessionId: checkpoint.sessionId,
+		agentId: checkpoint.agentId,
+		iteration: checkpoint.iteration,
+		messages: [...checkpoint.messages],
+		pendingToolCalls: checkpoint.pendingToolCalls.map((tc) => ({
+			toolCall: { ...tc.toolCall },
+			result: tc.result,
+			isError: tc.isError
+		})),
+		currentResponse: checkpoint.currentResponse,
+		currentThinking: checkpoint.currentThinking,
+		shouldContinue: checkpoint.shouldContinue,
+		stopReason: checkpoint.stopReason,
+		lastModelStopReason: checkpoint.lastModelStopReason,
+		usage: { ...checkpoint.usage },
+		metadata: { ...checkpoint.metadata }
+	};
+}
+
+//#endregion
+//#region src/agent/errors.ts
+/**
+* Error thrown when agent execution is aborted via AbortSignal
+*/
+var AgentAbortError = class extends Error {
+	constructor(message = "Agent execution aborted") {
+		super(message);
+		this.name = "AgentAbortError";
+	}
+};
+/**
+* Error thrown when agent exceeds maximum iterations
+*/
+var AgentMaxIterationsError = class extends Error {
+	iterations;
+	constructor(iterations, message) {
+		super(message ?? `Agent exceeded maximum iterations (${iterations})`);
+		this.name = "AgentMaxIterationsError";
+		this.iterations = iterations;
+	}
+};
+/**
+* Internal control-flow error used to stop streaming when execution is paused.
+*
+* This is caught by the Agent and is not intended to be shown to end users.
+*/
+var AgentPauseError = class extends Error {
+	constructor(message = "Agent execution paused") {
+		super(message);
+		this.name = "AgentPauseError";
+	}
+};
+/**
+* Check if the abort signal has been triggered and throw if so.
+*
+* @param signal - AbortSignal to check
+* @param context - Optional context for error message
+* @throws AgentAbortError if signal is aborted
+*/
+function ensureNotAborted(signal, context) {
+	if (!signal?.aborted) return;
+	const reason = signal?.reason;
+	if (reason instanceof Error) throw reason;
+	throw new AgentAbortError(typeof reason === "string" ? reason : context ? `${context} aborted` : "Agent execution aborted");
+}
+
+//#endregion
+//#region src/agent/middleware.ts
+/**
+* Compose multiple middleware functions into a single function.
+*
+* This implements an immutable onion model where each middleware:
+* - Receives state from the previous middleware (or initial state)
+* - Can transform state before passing to next()
+* - Returns the result from downstream processing
+*
+* Execution order for each iteration:
+* ```
+* outer:before → inner:before → exec (model.stream) → inner:after → outer:after
+* ```
+*
+* State flow:
+* ```
+* initialState → outer(transform?) → inner(transform?) → exec → result
+* ```
+*
+* @param middleware - Array of middleware functions
+* @returns Composed middleware function that can be invoked per iteration
+*
+* @example
+* ```ts
+* const composed = compose([
+*   async (state, next) => {
+*     console.log('outer:before');
+*     const result = await next(state);
+*     console.log('outer:after');
+*     return result;
+*   },
+*   async (state, next) => {
+*     console.log('inner:before');
+*     // Transform state before passing down
+*     const modified = { ...state, messages: compress(state.messages) };
+*     const result = await next(modified);
+*     console.log('inner:after');
+*     return result;
+*   },
+* ]);
+*
+* // Execute with core function
+* const result = await composed(initialState, async (s) => {
+*   // Core execution receives transformed state
+*   await model.stream(s.messages);
+*   return s;
+* });
+* ```
+*/
+function compose(middleware) {
+	return (initialState, exec) => {
+		let index = -1;
+		const dispatch = async (i, currentState) => {
+			if (i <= index) throw new Error("next() called multiple times");
+			index = i;
+			if (i === middleware.length) return exec ? await exec(currentState) : currentState;
+			const fn = middleware[i];
+			return fn(currentState, (nextState) => dispatch(i + 1, nextState));
+		};
+		return dispatch(0, initialState);
+	};
+}
+
+//#endregion
+//#region src/agent/types.ts
+/**
+* Create initial AgentLoopState from AgentInput
+*/
+function createInitialLoopState(input, agentId, systemPrompt) {
+	const messages = [
+		{
+			role: "system",
+			content: systemPrompt
+		},
+		...input.messages ?? [],
+		{
+			role: "user",
+			content: input.input
+		}
+	];
+	return {
+		sessionId: input.sessionId,
+		agentId,
+		messages,
+		iteration: 0,
+		pendingToolCalls: [],
+		currentResponse: "",
+		shouldContinue: true,
+		usage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		},
+		metadata: {}
+	};
+}
+/**
+* Create initial AgentLoopState from an existing message history (no new user message appended).
+*/
+function createInitialLoopStateFromMessages(input, agentId, systemPrompt) {
+	const normalized = Array.isArray(input.messages) ? input.messages : [];
+	const messages = [{
+		role: "system",
+		content: systemPrompt
+	}, ...normalized.length > 0 && normalized[0]?.role === "system" ? normalized.slice(1) : normalized];
+	return {
+		sessionId: input.sessionId,
+		agentId,
+		messages,
+		iteration: 0,
+		pendingToolCalls: [],
+		currentResponse: "",
+		shouldContinue: true,
+		usage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		},
+		metadata: {}
+	};
+}
+
+//#endregion
+//#region src/agent/agent.ts
+/** Default maximum iterations to prevent infinite loops */
+const DEFAULT_MAX_ITERATIONS = 10;
+/**
+* Agent class - the main orchestrator.
+*
+* Agent is a blueprint/configuration that can handle multiple sessions.
+* It composes model, tools, state store, and session manager.
+*
+* Supports middleware pattern for extensible hooks at each loop iteration.
+*/
+var Agent = class Agent {
+	id;
+	name;
+	systemPrompt;
+	createdAt;
+	_model;
+	_tools;
+	_stateStore;
+	_sessionManager;
+	_metadata;
+	_middlewares = [];
+	_stats = {
+		updatedAt: Date.now(),
+		totalSessions: 0,
+		activeSessions: 0,
+		totalUsage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		}
+	};
+	constructor(options) {
+		this.id = options.id ?? crypto.randomUUID();
+		this.name = options.name;
+		this.systemPrompt = options.systemPrompt;
+		this.createdAt = Date.now();
+		this._model = options.model;
+		this._tools = options.tools;
+		this._stateStore = options.stateStore;
+		this._sessionManager = options.sessionManager;
+	}
+	/**
+	* Get the current model
+	*/
+	get model() {
+		return this._model;
+	}
+	/**
+	* Get the tool registry
+	*/
+	get tools() {
+		return this._tools;
+	}
+	/**
+	* Get the state store
+	*/
+	get stateStore() {
+		return this._stateStore;
+	}
+	/**
+	* Get the session manager
+	*/
+	get sessionManager() {
+		return this._sessionManager;
+	}
+	/**
+	* Get runtime statistics
+	*/
+	get stats() {
+		return { ...this._stats };
+	}
+	/**
+	* Get metadata
+	*/
+	get metadata() {
+		return this._metadata;
+	}
+	/**
+	* Set metadata
+	*/
+	set metadata(value) {
+		this._metadata = value;
+	}
+	/**
+	* Add middleware to the agent.
+	*
+	* Middleware runs at each loop iteration and can intercept/transform the loop state.
+	* Middleware follows an immutable pattern - it receives state and returns new state via next().
+	*
+	* @param fn - Middleware function
+	* @returns this for chaining
+	*
+	* @example
+	* ```ts
+	* // Logging middleware (pass-through)
+	* agent.use(async (state, next) => {
+	*   console.log('Before iteration', state.iteration);
+	*   const result = await next(state);
+	*   console.log('After iteration', state.iteration);
+	*   return result;
+	* });
+	*
+	* // Transforming middleware (e.g., compression)
+	* agent.use(async (state, next) => {
+	*   const compressed = { ...state, messages: compress(state.messages) };
+	*   return next(compressed);
+	* });
+	* ```
+	*/
+	use(fn) {
+		this._middlewares.push(fn);
+		return this;
+	}
+	/**
+	* Switch to a different model
+	*
+	* @param model - New model to use
+	*/
+	setModel(model) {
+		this._model = model;
+		this._stats.updatedAt = Date.now();
+	}
+	/**
+	* Update session counts
+	*
+	* @param total - Total sessions
+	* @param active - Active sessions
+	*/
+	updateSessionCounts(total, active) {
+		this._stats.totalSessions = total;
+		this._stats.activeSessions = active;
+		this._stats.updatedAt = Date.now();
+	}
+	/**
+	* Add to total usage statistics
+	*
+	* @param usage - Usage to add
+	* @param usage.promptTokens - Number of prompt tokens
+	* @param usage.completionTokens - Number of completion tokens
+	* @param usage.totalTokens - Total number of tokens
+	*/
+	addUsage(usage) {
+		this._stats.totalUsage.promptTokens += usage.promptTokens;
+		this._stats.totalUsage.completionTokens += usage.completionTokens;
+		this._stats.totalUsage.totalTokens += usage.totalTokens;
+		this._stats.updatedAt = Date.now();
+	}
+	/**
+	* Create a snapshot of the agent for persistence
+	*
+	* @returns Agent snapshot
+	*/
+	toSnapshot() {
+		return {
+			id: this.id,
+			name: this.name,
+			createdAt: this.createdAt,
+			config: {
+				systemPrompt: this.systemPrompt,
+				model: { modelId: this._model.modelId },
+				tools: this._tools?.list().map((t) => t.name) ?? []
+			},
+			stats: { ...this._stats },
+			metadata: this._metadata
+		};
+	}
+	/**
+	* Restore agent state from a snapshot
+	*
+	* Note: This restores mutable state (stats, metadata) from a snapshot.
+	* The model and tools must be provided separately as they contain runtime instances.
+	*
+	* @param snapshot - Agent snapshot to restore from
+	*/
+	restoreFromSnapshot(snapshot) {
+		this._stats = {
+			updatedAt: snapshot.stats.updatedAt,
+			totalSessions: snapshot.stats.totalSessions,
+			activeSessions: snapshot.stats.activeSessions,
+			totalUsage: { ...snapshot.stats.totalUsage }
+		};
+		this._metadata = snapshot.metadata;
+	}
+	/**
+	* Execute model stream and collect events.
+	* This is the core execution that middleware wraps around.
+	*/
+	async executeModelStream(state, signal, tools, modelOverride) {
+		const events = [];
+		const toolCallAccumulator = /* @__PURE__ */ new Map();
+		const ensureToolCall = (callId) => {
+			const existing = toolCallAccumulator.get(callId);
+			if (existing) return existing;
+			const created = {
+				argsText: "",
+				started: false
+			};
+			toolCallAccumulator.set(callId, created);
+			return created;
+		};
+		const emitToolCallStartIfNeeded = (callId, toolName) => {
+			const entry = ensureToolCall(callId);
+			if (toolName && !entry.toolName) entry.toolName = toolName;
+			if (!entry.started) {
+				entry.started = true;
+				events.push({
+					type: "tool_call_start",
+					callId,
+					toolName: entry.toolName
+				});
+			}
+		};
+		const emitToolCallDelta = (callId, toolName, argsTextDelta) => {
+			const entry = ensureToolCall(callId);
+			if (toolName && !entry.toolName) entry.toolName = toolName;
+			if (typeof argsTextDelta === "string" && argsTextDelta.length > 0) entry.argsText += argsTextDelta;
+			emitToolCallStartIfNeeded(callId, entry.toolName);
+			events.push({
+				type: "tool_call_delta",
+				callId,
+				toolName: entry.toolName,
+				argsTextDelta
+			});
+		};
+		const finalizeToolCalls = () => {
+			for (const [callId, entry] of toolCallAccumulator) {
+				if (!entry.toolName) continue;
+				const toolCall = {
+					id: callId,
+					type: "function",
+					function: {
+						name: entry.toolName,
+						arguments: entry.argsText
+					}
+				};
+				if (this._tools) state.pendingToolCalls.push({ toolCall });
+				events.push({
+					type: "tool_call_end",
+					toolCall
+				});
+			}
+			toolCallAccumulator.clear();
+		};
+		const streamArgs = modelOverride ? {
+			model: modelOverride,
+			messages: state.messages,
+			tools
+		} : {
+			messages: state.messages,
+			tools
+		};
+		for await (const event of this._model.stream(streamArgs)) {
+			ensureNotAborted(signal, "Agent streaming");
+			if (event.type === "delta") {
+				if (event.chunk.kind === "text") {
+					state.currentResponse += event.chunk.text;
+					events.push({
+						type: "text_delta",
+						delta: event.chunk.text
+					});
+				} else if (event.chunk.kind === "thinking_start") events.push({ type: "thinking_start" });
+				else if (event.chunk.kind === "thinking_delta") {
+					state.currentThinking = (state.currentThinking ?? "") + event.chunk.text;
+					events.push({
+						type: "thinking_delta",
+						delta: event.chunk.text
+					});
+				} else if (event.chunk.kind === "thinking_end") events.push({ type: "thinking_end" });
+				else if (event.chunk.kind === "tool_call_delta") emitToolCallDelta(event.chunk.callId, event.chunk.toolId, event.chunk.argsTextDelta);
+			} else if (event.type === "response_end") {
+				finalizeToolCalls();
+				state.lastModelStopReason = event.stopReason;
+				const raw = event.usage;
+				if (raw && typeof raw === "object") {
+					const usage = raw;
+					if (usage.prompt_tokens || usage.completion_tokens || usage.total_tokens) {
+						const normalized = {
+							promptTokens: usage.prompt_tokens ?? 0,
+							completionTokens: usage.completion_tokens ?? 0,
+							totalTokens: usage.total_tokens ?? 0
+						};
+						state.usage.promptTokens += normalized.promptTokens;
+						state.usage.completionTokens += normalized.completionTokens;
+						state.usage.totalTokens += normalized.totalTokens;
+						this.addUsage(normalized);
+						events.push({
+							type: "usage",
+							usage: normalized
+						});
+					}
+				}
+			} else if (event.type === "error") {
+				const code = event.error?.code ?? "model_error";
+				const message = event.error?.message ?? "Model error";
+				const err = /* @__PURE__ */ new Error(`${code}: ${message}`);
+				err.code = code;
+				state.error = err;
+				state.shouldContinue = false;
+				state.stopReason = "error";
+				events.push({
+					type: "error",
+					error: err
+				});
+			} else if (event.type === "text_delta") {
+				state.currentResponse += event.delta;
+				events.push({
+					type: "text_delta",
+					delta: event.delta
+				});
+			} else if (event.type === "thinking_end" || event.type === "thinking_start") events.push({ type: event.type });
+			else if (event.type === "thinking_delta") {
+				state.currentThinking = (state.currentThinking ?? "") + event.content;
+				events.push({
+					type: "thinking_delta",
+					delta: event.content
+				});
+			} else if (event.type === "tool_call" && this._tools) {
+				const toolCall = event.toolCall;
+				events.push({
+					type: "tool_call_start",
+					callId: toolCall.id,
+					toolName: toolCall.function.name
+				});
+				state.pendingToolCalls.push({ toolCall });
+				events.push({
+					type: "tool_call_end",
+					toolCall
+				});
+			} else if (event.type === "usage") {
+				state.usage.promptTokens += event.usage.promptTokens;
+				state.usage.completionTokens += event.usage.completionTokens;
+				state.usage.totalTokens += event.usage.totalTokens;
+				this.addUsage(event.usage);
+				events.push({
+					type: "usage",
+					usage: event.usage
+				});
+			}
+		}
+		if (toolCallAccumulator.size > 0) finalizeToolCalls();
+		return events;
+	}
+	/**
+	* Execute a single tool call and return the result event.
+	*/
+	async executeToolCall(tc, ctx, signal) {
+		ensureNotAborted(signal, `Tool execution: ${tc.toolCall.function.name}`);
+		const tool = this._tools?.get(tc.toolCall.function.name);
+		if (!tool) {
+			tc.result = `Tool not found: ${tc.toolCall.function.name}`;
+			tc.isError = true;
+			return {
+				type: "tool_result",
+				tool_call_id: tc.toolCall.id,
+				result: tc.result,
+				isError: true
+			};
+		}
+		try {
+			const args = typeof tc.toolCall.function.arguments === "string" ? JSON.parse(tc.toolCall.function.arguments) : tc.toolCall.function.arguments;
+			tc.result = await tool.execute(args, ctx);
+			tc.isError = false;
+			return {
+				type: "tool_result",
+				tool_call_id: tc.toolCall.id,
+				result: tc.result
+			};
+		} catch (error) {
+			tc.result = error instanceof Error ? error.message : String(error);
+			tc.isError = true;
+			return {
+				type: "tool_result",
+				tool_call_id: tc.toolCall.id,
+				result: tc.result,
+				isError: true
+			};
+		}
+	}
+	createToolExecutionContext(state, signal, input) {
+		return {
+			sessionId: state.sessionId,
+			agentId: state.agentId,
+			context: input?.context,
+			signal,
+			capabilities: input?.capabilities,
+			usage: state.usage,
+			metadata: {
+				...state.metadata ?? {},
+				...input?.metadata ?? {}
+			}
+		};
+	}
+	/**
+	* Merge execution results from processedState back to original state.
+	*
+	* This preserves original messages (for checkpoint) while keeping:
+	* - currentResponse, currentThinking (from LLM)
+	* - pendingToolCalls (from LLM)
+	* - usage (accumulated)
+	* - metadata (middleware may update this)
+	*
+	* Note: If processedState shares references with state (shallow copy),
+	* some fields are already synced. This method ensures all fields are merged.
+	*/
+	mergeStateResults(state, processedState) {
+		state.currentResponse = processedState.currentResponse;
+		state.currentThinking = processedState.currentThinking;
+		state.pendingToolCalls = processedState.pendingToolCalls;
+		state.usage = processedState.usage;
+		state.metadata = processedState.metadata;
+	}
+	/**
+	* Add tool result to message history.
+	*/
+	addToolResultToHistory(state, tc) {
+		state.messages.push({
+			role: "tool",
+			tool_call_id: tc.toolCall.id,
+			content: typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result)
+		});
+	}
+	/**
+	* Add assistant message with tool calls to history.
+	*/
+	addAssistantMessageWithToolCalls(state) {
+		state.messages.push({
+			role: "assistant",
+			content: state.currentResponse || "",
+			tool_calls: state.pendingToolCalls.map((tc) => tc.toolCall)
+		});
+	}
+	/**
+	* Add final assistant response to history.
+	*/
+	addFinalAssistantMessage(state) {
+		if (state.currentResponse) state.messages.push({
+			role: "assistant",
+			content: state.currentResponse
+		});
+	}
+	/**
+	* Stream agent execution with proper agentic loop.
+	*
+	* The execution follows an immutable middleware pattern with checkpoint support:
+	* ```
+	* checkpoint:before (save original state)
+	*   → middleware chain (transforms state immutably)
+	*     → exec (model.stream with processed state)
+	*   → merge results back (except messages)
+	* checkpoint:after (save original state with original messages)
+	* ```
+	*
+	* Key invariant: checkpoint always saves the original messages, while
+	* LLM receives potentially transformed messages (e.g., compressed).
+	*/
+	async *streamWithState(state, input) {
+		const maxIterations = input.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+		const signal = input.signal;
+		const tools = this._tools?.toOpenAIFormat();
+		const runUserMiddleware = compose(this._middlewares);
+		const toolContext = this.createToolExecutionContext(state, signal, input.toolContext);
+		const stateStore = this._stateStore;
+		const savePoint = stateStore?.savePoint ?? "before";
+		const deleteOnComplete = stateStore?.deleteOnComplete ?? true;
+		const checkpointModelConfig = input.model ? {
+			modelId: input.model.modelId,
+			provider: input.model.provider
+		} : { modelId: this._model.modelId };
+		while (state.shouldContinue) {
+			ensureNotAborted(signal, `Agent iteration ${state.iteration}`);
+			if (state.iteration >= maxIterations) {
+				state.shouldContinue = false;
+				state.stopReason = "max_iterations";
+				yield {
+					type: "done",
+					finalResponse: state.currentResponse,
+					stopReason: "max_iterations",
+					modelStopReason: state.lastModelStopReason
+				};
+				break;
+			}
+			yield {
+				type: "iteration_start",
+				iteration: state.iteration
+			};
+			if (state.pendingToolCalls.length > 0) {
+				try {
+					yield* this.handleToolCalls(state, toolContext, {
+						signal,
+						toolContextInput: input.toolContext,
+						stateStore,
+						checkpointModelConfig,
+						requestParams: input.requestParams
+					});
+				} catch (error) {
+					if (error instanceof AgentPauseError) return;
+					throw error;
+				}
+				continue;
+			}
+			state.currentResponse = "";
+			state.currentThinking = void 0;
+			state.pendingToolCalls = [];
+			state.lastModelStopReason = void 0;
+			if (stateStore && (savePoint === "before" || savePoint === "both")) {
+				const checkpoint = toLoopCheckpoint(state, {
+					agentName: this.name,
+					modelConfig: checkpointModelConfig,
+					requestParams: input.requestParams
+				});
+				await stateStore.saveCheckpoint(checkpoint);
+			}
+			let collectedEvents = [];
+			const processedState = await runUserMiddleware(state, async (middlewareState) => {
+				ensureNotAborted(signal, "Agent model call");
+				collectedEvents = await this.executeModelStream(middlewareState, signal, tools, input.model);
+				return middlewareState;
+			});
+			this.mergeStateResults(state, processedState);
+			if (stateStore && (savePoint === "after" || savePoint === "both")) {
+				const checkpoint = toLoopCheckpoint(state, {
+					agentName: this.name,
+					modelConfig: checkpointModelConfig,
+					requestParams: input.requestParams
+				});
+				await stateStore.saveCheckpoint(checkpoint);
+			}
+			for (const event of collectedEvents) yield event;
+			ensureNotAborted(signal, `Agent iteration ${state.iteration}`);
+			if (state.stopReason === "error") {
+				yield {
+					type: "iteration_end",
+					iteration: state.iteration,
+					willContinue: false,
+					toolCallCount: state.pendingToolCalls.length
+				};
+				yield {
+					type: "done",
+					finalResponse: state.currentResponse,
+					stopReason: "error",
+					modelStopReason: state.lastModelStopReason
+				};
+				break;
+			}
+			if (state.pendingToolCalls.length > 0) try {
+				yield* this.handleToolCalls(state, toolContext, {
+					signal,
+					toolContextInput: input.toolContext,
+					stateStore,
+					checkpointModelConfig,
+					requestParams: input.requestParams
+				});
+			} catch (error) {
+				if (error instanceof AgentPauseError) return;
+				throw error;
+			}
+			else {
+				yield* this.handleFinalResponse(state);
+				if (stateStore && deleteOnComplete && state.stopReason === "final_response") await stateStore.deleteCheckpoint(state.sessionId);
+			}
+		}
+	}
+	async *stream(input) {
+		const state = createInitialLoopState(input, this.id, this.systemPrompt);
+		yield* this.streamWithState(state, {
+			maxIterations: input.maxIterations,
+			signal: input.signal,
+			model: input.model,
+			toolContext: input.toolContext,
+			requestParams: input.requestParams
+		});
+	}
+	/**
+	* Stream agent execution starting from an existing message history (no new user message appended).
+	*
+	* Useful for orchestration patterns like "handoff", where a different agent should
+	* continue the same conversation state under a different system prompt.
+	*/
+	async *streamFromMessages(input) {
+		const state = createInitialLoopStateFromMessages(input, this.id, this.systemPrompt);
+		yield* this.streamWithState(state, {
+			maxIterations: input.maxIterations,
+			signal: input.signal,
+			model: input.model,
+			toolContext: input.toolContext,
+			requestParams: input.requestParams
+		});
+	}
+	/**
+	* Stream agent execution from a saved checkpoint.
+	*
+	* This allows resuming interrupted executions from the exact state
+	* where they were saved (e.g., during tool approval waiting).
+	*
+	* @param input - Input containing the checkpoint to resume from
+	*
+	* @example
+	* ```typescript
+	* // Load checkpoint from store
+	* const checkpoint = await store.loadLoopCheckpoint(sessionId)
+	*
+	* if (checkpoint) {
+	*   // Resume execution from checkpoint
+	*   for await (const event of agent.streamFromCheckpoint({
+	*     checkpoint,
+	*     maxIterations: 10,
+	*   })) {
+	*     console.log(event)
+	*   }
+	* }
+	* ```
+	*/
+	async *streamFromCheckpoint(input) {
+		const state = fromLoopCheckpoint(input.checkpoint);
+		const requestParams = input.requestParams ?? input.checkpoint.requestParams;
+		yield* this.streamWithState(state, {
+			maxIterations: input.maxIterations,
+			signal: input.signal,
+			model: input.model,
+			toolContext: input.toolContext,
+			requestParams
+		});
+	}
+	/**
+	* Risk levels that require user approval before execution.
+	*/
+	static APPROVAL_REQUIRED_LEVELS = new Set(["high", "critical"]);
+	/**
+	* Check if a tool requires approval based on its risk level.
+	*/
+	requiresApproval(riskLevel) {
+		return Agent.APPROVAL_REQUIRED_LEVELS.has(riskLevel);
+	}
+	/**
+	* Handle tool calls: execute tools, yield results, continue loop.
+	*/
+	async *handleToolCalls(state, toolContext, options) {
+		const toolCallCount = state.pendingToolCalls.length;
+		const signal = options?.signal;
+		const toolContextInput = options?.toolContextInput;
+		const onToolApproval = toolContextInput?.onToolApproval;
+		const approval = toolContextInput?.approval;
+		const approvalStrategy = approval?.strategy ?? "high_risk";
+		const approvalEnabled = approval?.autoApprove !== true && (Boolean(onToolApproval) || approval?.strategy != null || approval?.decisions != null);
+		const approvalDecisions = approval?.decisions ?? {};
+		const shouldRequireApproval = (riskLevel) => {
+			if (!approvalEnabled) return false;
+			if (approvalStrategy === "all") return true;
+			return this.requiresApproval(riskLevel);
+		};
+		const hasAssistantToolCallMessage = (toolCallId) => {
+			return state.messages.some((m) => {
+				if (!m || typeof m !== "object" || m.role !== "assistant") return false;
+				const tc = m.tool_calls;
+				return Array.isArray(tc) && tc.some((c) => c?.id === toolCallId);
+			});
+		};
+		const addAssistantMessageIfNeeded = (toolCallId) => {
+			if (!hasAssistantToolCallMessage(toolCallId)) this.addAssistantMessageWithToolCalls(state);
+		};
+		const alreadyHasToolResultMessage = (toolCallId) => {
+			return state.messages.some((m) => m && typeof m === "object" && m.role === "tool" && m.tool_call_id === toolCallId);
+		};
+		for (const tc of state.pendingToolCalls) {
+			if (alreadyHasToolResultMessage(tc.toolCall.id)) continue;
+			const tool = this._tools?.get(tc.toolCall.function.name);
+			const riskLevel = tool?.riskLevel ?? "safe";
+			if (tool && shouldRequireApproval(riskLevel)) {
+				let args = {};
+				try {
+					args = typeof tc.toolCall.function.arguments === "string" ? JSON.parse(tc.toolCall.function.arguments) : tc.toolCall.function.arguments;
+				} catch {
+					args = { _raw: tc.toolCall.function.arguments };
+				}
+				const toolName = tc.toolCall.function.name;
+				let approvalResult = approvalDecisions[tc.toolCall.id];
+				if (!approvalResult && onToolApproval) {
+					yield {
+						type: "tool_approval_requested",
+						tool_call_id: tc.toolCall.id,
+						toolName,
+						riskLevel,
+						args
+					};
+					approvalResult = await onToolApproval({
+						toolName,
+						toolCall: tc.toolCall,
+						riskLevel,
+						args
+					});
+				}
+				if (!approvalResult) {
+					const checkpoint = toLoopCheckpoint(state, {
+						agentName: this.name,
+						phase: "approval_pending",
+						status: `Waiting for approval: ${toolName}`,
+						modelConfig: options?.checkpointModelConfig,
+						requestParams: options?.requestParams
+					});
+					if (options?.stateStore) await options.stateStore.saveCheckpoint(checkpoint);
+					yield {
+						type: "requires_action",
+						kind: "tool_approval",
+						tool_call_id: tc.toolCall.id,
+						toolName,
+						riskLevel,
+						args,
+						checkpoint: options?.stateStore ? void 0 : checkpoint,
+						checkpointRef: options?.stateStore ? {
+							sessionId: checkpoint.sessionId,
+							agentId: checkpoint.agentId
+						} : void 0
+					};
+					throw new AgentPauseError();
+				}
+				if ("pending" in approvalResult && approvalResult.pending) {
+					const checkpoint = toLoopCheckpoint(state, {
+						agentName: this.name,
+						phase: "approval_pending",
+						status: approvalResult.reason ? `Waiting for approval: ${toolName} (${approvalResult.reason})` : `Waiting for approval: ${toolName}`,
+						modelConfig: options?.checkpointModelConfig,
+						requestParams: options?.requestParams
+					});
+					if (options?.stateStore) await options.stateStore.saveCheckpoint(checkpoint);
+					yield {
+						type: "requires_action",
+						kind: "tool_approval",
+						tool_call_id: tc.toolCall.id,
+						toolName,
+						riskLevel,
+						args,
+						checkpoint: options?.stateStore ? void 0 : checkpoint,
+						checkpointRef: options?.stateStore ? {
+							sessionId: checkpoint.sessionId,
+							agentId: checkpoint.agentId
+						} : void 0
+					};
+					throw new AgentPauseError();
+				}
+				if (!("approved" in approvalResult) || !approvalResult.approved) {
+					const reason = approvalResult.reason ?? "User denied approval";
+					tc.result = `Tool execution skipped: ${reason}`;
+					tc.isError = true;
+					addAssistantMessageIfNeeded(tc.toolCall.id);
+					yield {
+						type: "tool_skipped",
+						tool_call_id: tc.toolCall.id,
+						toolName: tc.toolCall.function.name,
+						reason
+					};
+					yield {
+						type: "tool_result",
+						tool_call_id: tc.toolCall.id,
+						result: tc.result,
+						isError: true
+					};
+					this.addToolResultToHistory(state, tc);
+					continue;
+				}
+			}
+			addAssistantMessageIfNeeded(tc.toolCall.id);
+			yield await this.executeToolCall(tc, toolContext, signal);
+			this.addToolResultToHistory(state, tc);
+		}
+		state.pendingToolCalls = [];
+		state.iteration++;
+		yield {
+			type: "iteration_end",
+			iteration: state.iteration - 1,
+			willContinue: true,
+			toolCallCount
+		};
+	}
+	/**
+	* Handle final response: add to history, emit done.
+	*/
+	async *handleFinalResponse(state) {
+		state.shouldContinue = false;
+		state.stopReason = "final_response";
+		this.addFinalAssistantMessage(state);
+		yield {
+			type: "iteration_end",
+			iteration: state.iteration,
+			willContinue: false,
+			toolCallCount: 0
+		};
+		yield {
+			type: "done",
+			finalResponse: state.currentResponse,
+			stopReason: "final_response",
+			modelStopReason: state.lastModelStopReason
+		};
+	}
+};
+
+//#endregion
+//#region src/state/types.ts
+/**
+* Predefined state keys for common data types.
+*/
+const StateKeys = {
+	CHECKPOINT: "checkpoint",
+	COMPRESSION: "compression",
+	SESSION: "session",
+	COMPRESSION_SNAPSHOT: "compression-snapshot"
+};
+
+//#endregion
+//#region src/state/stateStore.ts
+/**
+* Abstract base class for state storage.
+*
+* StateStore provides a session-centric storage abstraction where all data
+* is organized by sessionId. Each session can have multiple keys storing
+* different types of data (checkpoint, compression state, session info, etc.).
+*
+* Subclasses only need to implement the low-level storage primitives:
+* - _write: Write data to a path
+* - _read: Read data from a path
+* - _delete: Delete data at a path
+* - _exists: Check if data exists at a path
+* - _list: List all paths with a given prefix
+*
+* The base class provides:
+* - High-level API for session-based storage (save, load, delete, etc.)
+* - Convenience methods for checkpoint operations
+* - JSON serialization/deserialization
+*
+* @example
+* ```typescript
+* // Using with an agent
+* const store = new FileStateStore({ dir: './state' })
+*
+* const agent = new Agent({
+*   name: 'MyAgent',
+*   stateStore: store,
+*   // ...
+* })
+*
+* // Manual state operations
+* await store.save(sessionId, 'custom-key', { myData: 123 })
+* const data = await store.load(sessionId, 'custom-key')
+* ```
+*/
+var StateStore = class {
+	/**
+	* When to save checkpoints during agent execution.
+	*/
+	savePoint;
+	/**
+	* Whether to delete checkpoint after successful completion.
+	*/
+	deleteOnComplete;
+	constructor(options) {
+		this.savePoint = options?.savePoint ?? "before";
+		this.deleteOnComplete = options?.deleteOnComplete ?? true;
+	}
+	/**
+	* Save data for a session under a specific key.
+	*
+	* @param sessionId - Session identifier
+	* @param key - Data key (e.g., 'checkpoint', 'compression', or custom keys)
+	* @param data - Data to save (will be JSON serialized)
+	*/
+	async save(sessionId, key, data) {
+		const path$1 = this.buildPath(sessionId, key);
+		const serialized = JSON.stringify(data, null, 2);
+		await this._write(path$1, serialized);
+	}
+	/**
+	* Load data for a session by key.
+	*
+	* @param sessionId - Session identifier
+	* @param key - Data key
+	* @returns The data or undefined if not found
+	*/
+	async load(sessionId, key) {
+		const path$1 = this.buildPath(sessionId, key);
+		const content = await this._read(path$1);
+		if (content === void 0) return;
+		try {
+			return JSON.parse(content);
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Delete data for a session by key.
+	*
+	* @param sessionId - Session identifier
+	* @param key - Data key
+	*/
+	async delete(sessionId, key) {
+		const path$1 = this.buildPath(sessionId, key);
+		await this._delete(path$1);
+	}
+	/**
+	* Delete all data for a session.
+	*
+	* @param sessionId - Session identifier
+	*/
+	async deleteSession(sessionId) {
+		const prefix = this.buildPrefix(sessionId);
+		const paths = await this._list(prefix);
+		await Promise.all(paths.map((path$1) => this._delete(path$1)));
+	}
+	/**
+	* List all keys for a session.
+	*
+	* @param sessionId - Session identifier
+	* @returns Array of keys
+	*/
+	async listKeys(sessionId) {
+		const prefix = this.buildPrefix(sessionId);
+		return (await this._list(prefix)).map((path$1) => this.extractKey(sessionId, path$1));
+	}
+	/**
+	* Check if data exists for a session key.
+	*
+	* @param sessionId - Session identifier
+	* @param key - Data key
+	* @returns True if data exists
+	*/
+	async exists(sessionId, key) {
+		const path$1 = this.buildPath(sessionId, key);
+		return this._exists(path$1);
+	}
+	/**
+	* Save an agent loop checkpoint.
+	*
+	* This is a convenience method that saves the checkpoint under the
+	* predefined CHECKPOINT key with additional metadata.
+	*
+	* @param checkpoint - Checkpoint to save
+	*/
+	async saveCheckpoint(checkpoint) {
+		const wrapped = {
+			_meta: {
+				description: "GoatChain Agent Loop Checkpoint - DO NOT EDIT MANUALLY",
+				savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				agentId: checkpoint.agentId,
+				agentName: checkpoint.agentName,
+				sessionId: checkpoint.sessionId,
+				iteration: checkpoint.iteration,
+				phase: checkpoint.phase,
+				status: checkpoint.status,
+				messageCount: checkpoint.messages.length,
+				toolCallsPending: checkpoint.pendingToolCalls?.length ?? 0
+			},
+			checkpoint
+		};
+		await this.save(checkpoint.sessionId, StateKeys.CHECKPOINT, wrapped);
+	}
+	/**
+	* Load an agent loop checkpoint by session ID.
+	*
+	* @param sessionId - Session identifier
+	* @returns Checkpoint or undefined if not found
+	*/
+	async loadCheckpoint(sessionId) {
+		return (await this.load(sessionId, StateKeys.CHECKPOINT))?.checkpoint;
+	}
+	/**
+	* Delete an agent loop checkpoint.
+	*
+	* @param sessionId - Session identifier
+	*/
+	async deleteCheckpoint(sessionId) {
+		await this.delete(sessionId, StateKeys.CHECKPOINT);
+	}
+	/**
+	* List all checkpoints across all sessions.
+	*
+	* @returns Array of checkpoints
+	*/
+	async listCheckpoints() {
+		const sessionIds = await this.listSessions();
+		const checkpoints = [];
+		for (const sessionId of sessionIds) {
+			const checkpoint = await this.loadCheckpoint(sessionId);
+			if (checkpoint) checkpoints.push(checkpoint);
+		}
+		return checkpoints;
+	}
+	/**
+	* List all session IDs that have stored data.
+	*
+	* @returns Array of session IDs
+	*/
+	async listSessions() {
+		const allPaths = await this._list("");
+		const sessionIds = /* @__PURE__ */ new Set();
+		for (const path$1 of allPaths) {
+			const sessionId = this.extractSessionId(path$1);
+			if (sessionId) sessionIds.add(sessionId);
+		}
+		return Array.from(sessionIds);
+	}
+	/**
+	* Build a storage path from sessionId and key.
+	* Default format: `{sessionId}/{key}`
+	*
+	* Subclasses can override this for different path formats.
+	*/
+	buildPath(sessionId, key) {
+		return `${sessionId}/${key}`;
+	}
+	/**
+	* Build a prefix for listing all data under a session.
+	* Default format: `{sessionId}/`
+	*/
+	buildPrefix(sessionId) {
+		return `${sessionId}/`;
+	}
+	/**
+	* Extract the key from a full path.
+	*/
+	extractKey(sessionId, path$1) {
+		const prefix = this.buildPrefix(sessionId);
+		return path$1.startsWith(prefix) ? path$1.slice(prefix.length) : path$1;
+	}
+	/**
+	* Extract the sessionId from a full path.
+	*/
+	extractSessionId(path$1) {
+		const parts = path$1.split("/");
+		return parts.length > 0 ? parts[0] : void 0;
+	}
+};
+
+//#endregion
+//#region src/state/FileStateStore.ts
+/**
+* File-based implementation of StateStore.
+*
+* Stores state data as JSON files in a directory structure organized by session:
+*
+* ```
+* <baseDir>/
+*   <sessionId>/
+*     checkpoint.json
+*     compression.json
+*     session.json
+*     custom-key.json
+* ```
+*
+* @example
+* ```typescript
+* const store = new FileStateStore({
+*   dir: './state',
+*   savePoint: 'before',
+*   deleteOnComplete: true,
+* })
+*
+* const agent = new Agent({
+*   name: 'MyAgent',
+*   stateStore: store,
+*   // ...
+* })
+* ```
+*/
+var FileStateStore = class extends StateStore {
+	baseDir;
+	constructor(options) {
+		super(options);
+		this.baseDir = path.resolve(options.dir);
+		this.ensureDir(this.baseDir);
+	}
+	async _write(storagePath, data) {
+		const filePath = this.toFilePath(storagePath);
+		this.ensureDir(path.dirname(filePath));
+		writeFileSync(filePath, data, "utf-8");
+	}
+	async _read(storagePath) {
+		const filePath = this.toFilePath(storagePath);
+		try {
+			if (!existsSync(filePath)) return;
+			return readFileSync(filePath, "utf-8");
+		} catch {
+			return;
+		}
+	}
+	async _delete(storagePath) {
+		const filePath = this.toFilePath(storagePath);
+		if (existsSync(filePath)) rmSync(filePath);
+		const sessionDir = path.dirname(filePath);
+		if (existsSync(sessionDir)) try {
+			if (readdirSync(sessionDir).length === 0) rmSync(sessionDir, { recursive: true });
+		} catch {}
+	}
+	async _exists(storagePath) {
+		return existsSync(this.toFilePath(storagePath));
+	}
+	async _list(prefix) {
+		const results = [];
+		if (!existsSync(this.baseDir)) return results;
+		const sessionDirs = readdirSync(this.baseDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+		for (const sessionId of sessionDirs) {
+			if (prefix && !sessionId.startsWith(prefix.split("/")[0])) continue;
+			const sessionDir = path.join(this.baseDir, sessionId);
+			const files = this.listJsonFiles(sessionDir);
+			for (const file of files) {
+				const storagePath = `${sessionId}/${path.basename(file, ".json")}`;
+				if (!prefix || storagePath.startsWith(prefix)) results.push(storagePath);
+			}
+		}
+		return results;
+	}
+	/**
+	* Convert storage path to file system path.
+	* Storage path: `{sessionId}/{key}`
+	* File path: `{baseDir}/{sessionId}/{key}.json`
+	*/
+	toFilePath(storagePath) {
+		return path.join(this.baseDir, `${storagePath}.json`);
+	}
+	/**
+	* Ensure a directory exists.
+	*/
+	ensureDir(dir) {
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	}
+	/**
+	* List all JSON files in a directory.
+	*/
+	listJsonFiles(dir) {
+		if (!existsSync(dir)) return [];
+		return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => path.join(dir, f));
+	}
+	/**
+	* Get the base directory path.
+	*/
+	getBaseDir() {
+		return this.baseDir;
+	}
+	/**
+	* Clear all state data from the store.
+	* WARNING: This will delete all files in the base directory.
+	*/
+	clear() {
+		if (existsSync(this.baseDir)) {
+			rmSync(this.baseDir, { recursive: true });
+			mkdirSync(this.baseDir, { recursive: true });
+		}
+	}
+};
+
+//#endregion
+//#region src/state/InMemoryStateStore.ts
+/**
+* In-memory implementation of StateStore.
+*
+* Useful for development, testing, and short-lived applications.
+* Data is lost when the process exits.
+*
+* @example
+* ```typescript
+* const store = new InMemoryStateStore({
+*   savePoint: 'before',
+*   deleteOnComplete: true,
+* })
+*
+* const agent = new Agent({
+*   name: 'MyAgent',
+*   stateStore: store,
+*   // ...
+* })
+* ```
+*/
+var InMemoryStateStore = class extends StateStore {
+	/**
+	* Internal storage: path -> data
+	*/
+	store = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super(options);
+	}
+	async _write(path$1, data) {
+		this.store.set(path$1, data);
+	}
+	async _read(path$1) {
+		return this.store.get(path$1);
+	}
+	async _delete(path$1) {
+		this.store.delete(path$1);
+	}
+	async _exists(path$1) {
+		return this.store.has(path$1);
+	}
+	async _list(prefix) {
+		const paths = [];
+		for (const key of this.store.keys()) if (prefix === "" || key.startsWith(prefix)) paths.push(key);
+		return paths;
+	}
+	/**
+	* Clear all data from the store.
+	* Useful for testing.
+	*/
+	clear() {
+		this.store.clear();
+	}
+	/**
+	* Get statistics about the store.
+	*/
+	stats() {
+		const sessionIds = /* @__PURE__ */ new Set();
+		for (const key of this.store.keys()) {
+			const sessionId = this.extractSessionId(key);
+			if (sessionId) sessionIds.add(sessionId);
+		}
+		return {
+			entryCount: this.store.size,
+			sessionCount: sessionIds.size
+		};
+	}
+};
+
+//#endregion
+//#region src/agent/tokenCounter.ts
+let cachedTiktoken;
+function loadTiktoken() {
+	if (cachedTiktoken !== void 0) return cachedTiktoken;
+	try {
+		const mod = createRequire(import.meta.url)("tiktoken");
+		cachedTiktoken = mod;
+		return mod;
+	} catch {
+		cachedTiktoken = null;
+		return null;
+	}
+}
+/**
+* Default model to use for token encoding.
+*/
+const DEFAULT_MODEL = "gpt-4o";
+/**
+* Count tokens in a string using the specified model's encoding.
+*
+* Creates a new encoder for each call and immediately frees it
+* to avoid memory leaks in long-running processes.
+*
+* @param text - The text to count tokens for
+* @param model - Optional model name for encoding (default: gpt-4o)
+* @returns Number of tokens
+*/
+function countTokens(text, model) {
+	if (!text) return 0;
+	const tk = loadTiktoken();
+	if (!tk) return Math.ceil(text.length / 4);
+	let encoder = null;
+	try {
+		encoder = model ? tk.encoding_for_model(model) : tk.encoding_for_model(DEFAULT_MODEL);
+		return encoder.encode(text).length;
+	} catch (_error) {
+		console.error("Error encoding text:", _error);
+		try {
+			encoder = tk.get_encoding("cl100k_base");
+			return encoder.encode(text).length;
+		} catch {
+			return Math.ceil(text.length / 4);
+		}
+	} finally {
+		encoder?.free();
+	}
+}
+/**
+* Count tokens in a message content.
+* Handles both string content and array content (for multimodal messages).
+*
+* @param content - Message content (string or array)
+* @param model - Optional model name for encoding
+* @returns Number of tokens
+*/
+function countContentTokens(content, model) {
+	if (typeof content === "string") return countTokens(content, model);
+	if (Array.isArray(content)) return content.reduce((sum, part) => {
+		if (typeof part === "object" && part !== null && "text" in part) return sum + countTokens(String(part.text), model);
+		return sum;
+	}, 0);
+	return 0;
+}
+/**
+* Count tokens for a single message by serializing it to JSON.
+*
+* This method is more accurate as it accounts for JSON structure overhead
+* that the actual API will see.
+*
+* @param message - The message to count tokens for
+* @param model - Optional model name for encoding
+* @returns Number of tokens
+*/
+function countMessageTokens(message, model) {
+	try {
+		return countTokens(JSON.stringify(message), model);
+	} catch {
+		return countMessageTokensManual(message, model);
+	}
+}
+/**
+* Manual token counting for a single message (fallback method).
+* Includes role overhead and content tokens.
+*/
+function countMessageTokensManual(message, model) {
+	let tokens = 4;
+	tokens += countContentTokens(message.content, model);
+	if (message.role === "assistant" && message.tool_calls) for (const tc of message.tool_calls) {
+		tokens += countTokens(tc.function.name, model);
+		const args = typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments);
+		tokens += countTokens(args, model);
+		tokens += 10;
+	}
+	if (message.role === "tool" && message.name) tokens += countTokens(message.name, model);
+	if (message.role === "assistant" && message.reasoning_content) tokens += countTokens(message.reasoning_content, model);
+	return tokens;
+}
+/**
+* Count total tokens in a message array.
+*
+* Serializes the entire messages array to JSON for accurate counting,
+* as this reflects what the actual API will receive.
+*
+* @param messages - Array of messages
+* @param model - Optional model name for encoding
+* @returns Total number of tokens
+*/
+function countMessagesTokens(messages, model) {
+	if (!messages || messages.length === 0) return 0;
+	try {
+		return countTokens(JSON.stringify(messages), model);
+	} catch {
+		return messages.reduce((sum, msg) => sum + countMessageTokens(msg, model), 3);
+	}
+}
+
+//#endregion
+//#region src/agent/contextCompressionMiddleware.ts
+/**
+* Placeholder text for cleared tool outputs.
+*/
+const CLEARED_TOOL_OUTPUT = "[Old tool result content cleared]";
+/**
+* Default summary generation prompt.
+*/
+const DEFAULT_SUMMARY_PROMPT = `You are Claude Code, Anthropic's official CLI for Claude.
+
+You are a helpful AI assistant tasked with summarizing conversations.
+
+Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.
+This summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing development work without losing context.
+
+Before providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:
+
+1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:
+   - The user's explicit requests and intents
+   - Your approach to addressing the user's requests
+   - Key decisions, technical concepts and code patterns
+   - Specific details like:
+     - file names
+     - full code snippets
+     - function signatures
+     - file edits
+  - Errors that you ran into and how you fixed them
+  - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+2. Double-check for technical accuracy and completeness, addressing each required element thoroughly.
+
+Your summary should include the following sections:
+
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
+6. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+7. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+8. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests or really old requests that were already completed without confirming with the user first.
+                       If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.
+
+Here's an example of how your output should be structured:
+
+<example>
+<analysis>
+[Your thought process, ensuring all points are covered thoroughly and accurately]
+</analysis>
+
+<summary>
+1. Primary Request and Intent:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [Concept 2]
+   - [...]
+
+3. Files and Code Sections:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Summary of the changes made to this file, if any]
+      - [Important Code Snippet]
+   - [File Name 2]
+      - [Important Code Snippet]
+   - [...]
+
+4. Errors and fixes:
+    - [Detailed description of error 1]:
+      - [How you fixed the error]
+      - [User feedback on the error if any]
+    - [...]
+
+5. Problem Solving:
+   [Description of solved problems and ongoing troubleshooting]
+
+6. All user messages:
+    - [Detailed non tool use user message]
+    - [...]
+
+7. Pending Tasks:
+   - [Task 1]
+   - [Task 2]
+   - [...]
+
+8. Current Work:
+   [Precise description of current work]
+
+9. Optional Next Step:
+   [Optional Next step to take]
+
+</summary>
+</example>
+
+Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response.
+
+There may be additional summarization instructions provided in the included context. If so, remember to follow these instructions when creating the above summary. Examples of instructions include:
+<example>
+## Compact Instructions
+When summarizing the conversation focus on typescript code changes and also remember the mistakes you made and how you fixed them.
+</example>
+
+<example>
+# Summary instructions
+When you are using compact - please focus on test output and code changes. Include file reads verbatim.
+</example>
+
+Existing summary (may be empty):
+{{existingSummary}}
+
+Messages to summarize:
+{{toolOutputs}}
+`;
+/**
+* Create a context compression middleware.
+*
+* This middleware automatically compresses conversation history when it exceeds
+* the configured token limit. It follows an immutable pattern - original messages
+* are never modified. Instead, compressed messages are passed to the LLM while
+* the original messages remain unchanged (preserved for checkpoint).
+*
+* Compression strategy:
+* 1. Preserve message structure (all messages remain, including tool calls)
+* 2. Protect recent N turns completely
+* 3. Protect recent tool outputs up to token limit
+* 4. Clear old tool outputs with placeholder: "[Old tool result content cleared]"
+* 5. Optionally generate a summary of cleared content
+*
+* @param options - Compression configuration options
+* @returns Middleware function
+*
+* @example
+* ```ts
+* const agent = new Agent({ model, ... })
+*
+* // Basic usage - just clear old tool outputs
+* agent.use(createContextCompressionMiddleware({
+*   contextLimit: 128000,
+*   outputLimit: 4096,
+* }))
+*
+* // With summary generation and persistence
+* agent.use(createContextCompressionMiddleware({
+*   contextLimit: 128000,
+*   outputLimit: 4096,
+*   enableSummary: true,
+*   getModel: () => agent.model,
+*   getStateStore: () => agent.stateStore,
+* }))
+* ```
+*/
+function createContextCompressionMiddleware(options) {
+	const { contextLimit, outputLimit, protectedTurns = 2, protectedToolTokens = 4e4, trimToolOutputThreshold = 2e4, enableSummary = false, model, getModel, summaryPrompt = DEFAULT_SUMMARY_PROMPT, stateStore, getStateStore, persistClearedContent = false, onCompressionStart, onCompressionEnd } = options;
+	if (enableSummary && !model && !getModel) throw new Error("ContextCompressionMiddleware: \"model\" or \"getModel\" required when enableSummary is true");
+	const compressionThreshold = contextLimit - outputLimit;
+	return async (state, next) => {
+		const store = stateStore ?? getStateStore?.();
+		let compressionState;
+		if (store) compressionState = await store.load(state.sessionId, StateKeys.COMPRESSION);
+		let messagesWithSummary = state.messages;
+		if (compressionState?.summary) {
+			if (!messagesWithSummary.some((m) => m.role === "user" && typeof m.content === "string" && m.content.startsWith("[Context from cleared tool outputs]"))) {
+				const systemIndex = messagesWithSummary.findIndex((m) => m.role === "system");
+				const insertIndex = systemIndex >= 0 ? systemIndex + 1 : 0;
+				messagesWithSummary = [
+					...messagesWithSummary.slice(0, insertIndex),
+					{
+						role: "user",
+						content: `[Context from cleared tool outputs]\n${compressionState.summary}`
+					},
+					...messagesWithSummary.slice(insertIndex)
+				];
+				console.log(`📋 [Compression] Auto-loaded summary (${compressionState.summary.length} chars) into messages at index ${insertIndex}`);
+			}
+		}
+		if (countMessagesTokens(messagesWithSummary) > compressionThreshold) {
+			const summaryModel = enableSummary ? model ?? getModel?.() : void 0;
+			const { compressedMessages, stats, summary } = await compressMessagesImmutable(messagesWithSummary, {
+				protectedTurns,
+				protectedToolTokens,
+				trimToolOutputThreshold,
+				targetTokens: compressionThreshold,
+				enableSummary,
+				summaryPrompt
+			}, summaryModel, compressionState?.summary, onCompressionStart, onCompressionEnd);
+			const processedState = {
+				...state,
+				messages: compressedMessages,
+				metadata: {
+					...state.metadata,
+					lastCompression: stats
+				}
+			};
+			if (store) {
+				const now = Date.now();
+				const newCompressionState = {
+					lastStats: stats,
+					history: [...compressionState?.history ?? [], stats],
+					summary,
+					updatedAt: now
+				};
+				await store.save(state.sessionId, StateKeys.COMPRESSION, newCompressionState);
+				if (persistClearedContent) {
+					const snapshot = {
+						messages: compressedMessages.map((msg) => ({
+							role: msg.role,
+							content: msg.content,
+							tool_call_id: msg.tool_call_id,
+							name: msg.name,
+							tool_calls: "tool_calls" in msg ? msg.tool_calls : void 0
+						})),
+						stats,
+						timestamp: now
+					};
+					const snapshotKey = `${StateKeys.COMPRESSION_SNAPSHOT}-${now}`;
+					await store.save(state.sessionId, snapshotKey, snapshot);
+				}
+			}
+			return next(processedState);
+		}
+		if (messagesWithSummary !== state.messages) return next({
+			...state,
+			messages: messagesWithSummary
+		});
+		return next(state);
+	};
+}
+/**
+* Compress messages immutably by creating new messages array with cleared tool outputs.
+*
+* Strategy:
+* 1. Identify protected turns (recent N turns are fully protected)
+* 2. Identify protected tool outputs (recent outputs up to token limit)
+* 3. Create new messages with unprotected tool outputs cleared
+* 4. Trim protected but large tool outputs
+* 5. Optionally generate summary of cleared content
+*
+* This function never modifies the input messages array.
+*/
+async function compressMessagesImmutable(originalMessages, options, model, existingSummary, onStart, onEnd) {
+	const { protectedTurns, protectedToolTokens, trimToolOutputThreshold, enableSummary, summaryPrompt } = options;
+	const tokensBefore = countMessagesTokens(originalMessages);
+	console.log(`\n🗜️  [Compression] Starting compression process...`);
+	console.log(`   📊 Tokens before: ${tokensBefore.toLocaleString()}`);
+	console.log(`   🎯 Target tokens: ${options.targetTokens.toLocaleString()}`);
+	const protectedBoundary = findProtectedBoundary(originalMessages, protectedTurns);
+	console.log(`   🛡️  Protected turns boundary: index ${protectedBoundary} (protecting ${protectedTurns} turns)`);
+	const { protectedToolIds, unprotectedToolMessages } = categorizeToolMessages(originalMessages, protectedBoundary, protectedToolTokens);
+	console.log(`   🔒 Protected tool outputs: ${protectedToolIds.size}`);
+	console.log(`   🗑️  Tool outputs to clear: ${unprotectedToolMessages.length}`);
+	const initialStats = {
+		tokensBefore,
+		tokensAfter: 0,
+		clearedToolOutputs: unprotectedToolMessages.length,
+		trimmedToolOutputs: 0,
+		summaryGenerated: false,
+		timestamp: Date.now()
+	};
+	onStart?.(initialStats);
+	const clearedContents = [];
+	let trimmedCount = 0;
+	const compressedMessages = originalMessages.map((msg) => {
+		if (msg.role === "tool") {
+			const toolMsg = msg;
+			if (!protectedToolIds.has(toolMsg.tool_call_id)) {
+				const originalContent = typeof toolMsg.content === "string" ? toolMsg.content : JSON.stringify(toolMsg.content);
+				clearedContents.push({
+					name: toolMsg.name,
+					content: originalContent
+				});
+				return {
+					...toolMsg,
+					content: CLEARED_TOOL_OUTPUT
+				};
+			} else if (countContentTokens(toolMsg.content) > trimToolOutputThreshold) {
+				trimmedCount++;
+				return trimToolOutput(toolMsg, trimToolOutputThreshold);
+			}
+		}
+		return msg;
+	});
+	let newSummary = existingSummary;
+	if (enableSummary && model && clearedContents.length > 0) {
+		console.log(`\n📝 [Compression] Starting summary generation for ${clearedContents.length} cleared tool outputs...`);
+		const generatedSummary = (await generateSummary(clearedContents, model, summaryPrompt, existingSummary)).trim();
+		if (generatedSummary.length > 0) {
+			console.log(`✅ [Compression] Summary generated (${generatedSummary.length} chars)`);
+			newSummary = generatedSummary;
+			const existingSummaryIndex = compressedMessages.findIndex((m) => m.role === "user" && typeof m.content === "string" && m.content.startsWith("[Context from cleared tool outputs]"));
+			if (existingSummaryIndex >= 0) {
+				console.log(`🗑️  [Compression] Removing existing summary message at index ${existingSummaryIndex}`);
+				compressedMessages.splice(existingSummaryIndex, 1);
+			}
+			const systemIndex = compressedMessages.findIndex((m) => m.role === "system");
+			const insertIndex = systemIndex >= 0 ? systemIndex + 1 : 0;
+			console.log(`📌 [Compression] Inserting summary message at index ${insertIndex} (after system message)`);
+			compressedMessages.splice(insertIndex, 0, {
+				role: "user",
+				content: `[Context from cleared tool outputs]\n${newSummary}`
+			});
+		}
+	}
+	let mergedMessages = mergeAdjacentUserMessages(compressedMessages);
+	const tokensAfter = countMessagesTokens(mergedMessages);
+	if (enableSummary && newSummary && tokensAfter > options.targetTokens) {
+		const summaryMessageIndex = compressedMessages.findIndex((m) => m.role === "user" && typeof m.content === "string" && m.content.startsWith("[Context from cleared tool outputs]"));
+		if (summaryMessageIndex >= 0) {
+			const summaryMessage = compressedMessages[summaryMessageIndex];
+			const summaryContent = typeof summaryMessage.content === "string" ? summaryMessage.content : "";
+			const summaryTokens = countContentTokens(summaryContent);
+			const excessTokens = tokensAfter - options.targetTokens;
+			if (summaryTokens > excessTokens) {
+				console.log(`   ⚠️  [Compression] Summary too large (${summaryTokens} tokens), truncating...`);
+				const targetSummaryTokens = Math.max(100, summaryTokens - excessTokens - 100);
+				const targetSummaryChars = targetSummaryTokens * 4;
+				const truncatedSummary = summaryContent.slice(0, targetSummaryChars - 43) + "\n\n[... summary truncated due to length ...]";
+				compressedMessages[summaryMessageIndex] = {
+					...summaryMessage,
+					content: truncatedSummary
+				};
+				console.log(`   ✂️  [Compression] Summary truncated from ${summaryTokens} to ~${targetSummaryTokens} tokens`);
+			}
+		}
+	}
+	mergedMessages = mergeAdjacentUserMessages(compressedMessages);
+	const finalTokensAfter = countMessagesTokens(mergedMessages);
+	const tokensSaved = tokensBefore - finalTokensAfter;
+	const compressionRatio = (tokensSaved / tokensBefore * 100).toFixed(1);
+	console.log(`\n✅ [Compression] Compression completed:`);
+	console.log(`   📊 Tokens: ${tokensBefore.toLocaleString()} → ${finalTokensAfter.toLocaleString()} (saved ${tokensSaved.toLocaleString()}, ${compressionRatio}%)`);
+	console.log(`   🗑️  Cleared: ${clearedContents.length} tool outputs`);
+	console.log(`   ✂️  Trimmed: ${trimmedCount} tool outputs`);
+	console.log(`   📝 Summary: ${enableSummary && clearedContents.length > 0 ? "Generated" : "Not generated"}`);
+	if (finalTokensAfter > options.targetTokens) console.log(`   ⚠️  [Compression] WARNING: Still exceeds target by ${finalTokensAfter - options.targetTokens} tokens`);
+	const finalStats = {
+		tokensBefore,
+		tokensAfter: finalTokensAfter,
+		clearedToolOutputs: clearedContents.length,
+		trimmedToolOutputs: trimmedCount,
+		summaryGenerated: enableSummary && clearedContents.length > 0,
+		timestamp: Date.now()
+	};
+	onEnd?.(finalStats);
+	return {
+		compressedMessages: mergedMessages,
+		stats: finalStats,
+		summary: newSummary,
+		clearedContents
+	};
+}
+/**
+* Find the message index that marks the start of protected turns.
+* Messages at or after this index are protected.
+*/
+function findProtectedBoundary(messages, protectedTurns) {
+	if (protectedTurns <= 0) return messages.length;
+	let turnCount = 0;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "user") {
+		turnCount++;
+		if (turnCount >= protectedTurns) return i;
+	}
+	return 0;
+}
+/**
+* Categorize tool messages into protected and unprotected groups.
+*/
+function categorizeToolMessages(messages, protectedBoundary, protectedToolTokens) {
+	const protectedToolIds = /* @__PURE__ */ new Set();
+	const unprotectedToolMessages = [];
+	for (let i = protectedBoundary; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg.role === "tool") protectedToolIds.add(msg.tool_call_id);
+	}
+	let toolTokens = 0;
+	for (let i = protectedBoundary - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "tool") {
+			const toolMsg = msg;
+			const msgTokens = countContentTokens(toolMsg.content);
+			if (toolTokens + msgTokens <= protectedToolTokens) {
+				protectedToolIds.add(toolMsg.tool_call_id);
+				toolTokens += msgTokens;
+			}
+		}
+	}
+	for (let i = 0; i < protectedBoundary; i++) {
+		const msg = messages[i];
+		if (msg.role === "tool") {
+			const toolMsg = msg;
+			if (!protectedToolIds.has(toolMsg.tool_call_id)) unprotectedToolMessages.push(toolMsg);
+		}
+	}
+	return {
+		protectedToolIds,
+		unprotectedToolMessages
+	};
+}
+/**
+* Trim a tool message output to fit within token limit.
+*/
+function trimToolOutput(msg, maxTokens) {
+	const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+	const maxChars = maxTokens * 4;
+	const truncationMarker = "\n\n[... content truncated due to length ...]";
+	if (content.length <= maxChars) return msg;
+	const truncatedContent = content.slice(0, maxChars - 43) + truncationMarker;
+	return {
+		...msg,
+		content: truncatedContent
+	};
+}
+function mergeAdjacentUserMessages(messages) {
+	const merged = [];
+	for (const msg of messages) {
+		if (msg.role !== "user") {
+			merged.push(msg);
+			continue;
+		}
+		const last = merged[merged.length - 1];
+		if (last && last.role === "user") {
+			if (last.name === msg.name) {
+				merged[merged.length - 1] = {
+					...last,
+					content: mergeUserContent(last.content, msg.content)
+				};
+				continue;
+			}
+		}
+		merged.push(msg);
+	}
+	return merged;
+}
+function mergeUserContent(left, right) {
+	return [...toContentBlocks(left), ...toContentBlocks(right)];
+}
+function toContentBlocks(content) {
+	if (typeof content === "string") return content.trim().length > 0 ? [{
+		type: "text",
+		text: content
+	}] : [];
+	if (Array.isArray(content)) {
+		const blocks = [];
+		const items = content;
+		for (const item of items) {
+			if (typeof item === "string") {
+				const trimmed = item.trim();
+				if (trimmed.length > 0) blocks.push({
+					type: "text",
+					text: trimmed
+				});
+				continue;
+			}
+			if (item && typeof item === "object" && "type" in item) {
+				const block = item;
+				if (block.type === "text") {
+					const text = block.text;
+					if (typeof text === "string" && text.trim().length === 0) continue;
+				}
+				blocks.push(block);
+				continue;
+			}
+			if (item !== null && item !== void 0) {
+				const text = String(item);
+				if (text.trim().length > 0) blocks.push({
+					type: "text",
+					text
+				});
+			}
+		}
+		return blocks;
+	}
+	if (content && typeof content === "object" && "type" in content) {
+		const block = content;
+		if (block.type === "text") {
+			const text = block.text;
+			if (typeof text === "string" && text.trim().length === 0) return [];
+		}
+		return [block];
+	}
+	const fallback = String(content);
+	return fallback.trim().length > 0 ? [{
+		type: "text",
+		text: fallback
+	}] : [];
+}
+/**
+* Generate a summary of cleared tool outputs using the model.
+*/
+async function generateSummary(clearedContents, model, summaryPrompt, existingSummary) {
+	const formattedContent = clearedContents.map(({ name, content }) => {
+		return `## ${name ?? "unknown_tool"}\n${content.length > 5e3 ? `${content.slice(0, 5e3)}...[truncated for summary]` : content}`;
+	}).join("\n\n---\n\n");
+	const fullPrompt = buildSummaryPrompt(summaryPrompt, formattedContent, existingSummary);
+	const promptTokens = Math.ceil(fullPrompt.length / 4);
+	console.log(`   🤖 [Summary] Calling model (${model.modelId || "unknown"}) to generate summary...`);
+	console.log(`   📊 [Summary] Input: ${clearedContents.length} tool outputs, ~${promptTokens} tokens`);
+	console.log(`   📥 [Summary] Input content preview (first 500 chars):`);
+	console.log(`      ${formattedContent.slice(0, 500)}${formattedContent.length > 500 ? "..." : ""}`);
+	const startTime = Date.now();
+	const response = await model.invoke([{
+		role: "system",
+		content: "You are a helpful assistant that creates concise summaries."
+	}, {
+		role: "user",
+		content: fullPrompt
+	}], { maxTokens: 1e3 });
+	const duration = Date.now() - startTime;
+	const summary = typeof response.message.content === "string" ? response.message.content : JSON.stringify(response.message.content);
+	console.log(`   ⏱️  [Summary] Model call completed in ${duration}ms`);
+	console.log(`   📄 [Summary] Generated summary (${summary.length} chars):`);
+	console.log(`      ${summary}`);
+	console.log(`   📊 [Summary] Compression ratio: ${formattedContent.length} → ${summary.length} chars (${((1 - summary.length / formattedContent.length) * 100).toFixed(1)}% reduction)`);
+	return summary;
+}
+function buildSummaryPrompt(summaryPrompt, formattedContent, existingSummary) {
+	const hasToolOutputs = summaryPrompt.includes("{{toolOutputs}}");
+	const hasExistingSummary = summaryPrompt.includes("{{existingSummary}}");
+	const baseSummary = existingSummary ?? "";
+	if (hasToolOutputs || hasExistingSummary) return summaryPrompt.split("{{toolOutputs}}").join(formattedContent).split("{{existingSummary}}").join(baseSummary);
+	return `${summaryPrompt}\n\n${baseSummary.length > 0 ? `Existing summary:\n${baseSummary}\n\nTool outputs to summarize:\n${formattedContent}` : `Tool outputs to summarize:\n${formattedContent}`}`;
+}
+/**
+* Manually compress a session by generating a summary from full message history.
+*
+* This function extracts all tool outputs from the full messages and generates
+* a new summary based on the complete context. The summary is saved to
+* CompressionState and will be automatically loaded by the middleware on next run.
+*
+* @param options - Manual compression options
+* @returns Compression result with generated summary
+*
+* @example
+* ```ts
+* const result = await compressSessionManually({
+*   sessionId: 'session-123',
+*   fullMessages: allMessages,
+*   model: myModel,
+*   stateStore: myStore,
+* })
+* console.log(`Generated summary: ${result.summary}`)
+* ```
+*/
+async function compressSessionManually(options) {
+	const { sessionId, fullMessages, model, stateStore, summaryPrompt = DEFAULT_SUMMARY_PROMPT } = options;
+	console.log(`\n📝 [Manual Compression] Starting manual compression for session ${sessionId}...`);
+	console.log(`   📊 Total messages: ${fullMessages.length}`);
+	const toolOutputs = [];
+	for (const msg of fullMessages) if (msg.role === "tool") {
+		const toolMsg = msg;
+		const content = typeof toolMsg.content === "string" ? toolMsg.content : JSON.stringify(toolMsg.content);
+		toolOutputs.push({
+			name: toolMsg.name,
+			content
+		});
+	}
+	console.log(`   🔧 Tool outputs found: ${toolOutputs.length}`);
+	if (toolOutputs.length === 0) {
+		console.log(`   ⚠️  [Manual Compression] No tool outputs found, nothing to summarize`);
+		return {
+			summary: "",
+			messageCount: fullMessages.length,
+			toolOutputCount: 0
+		};
+	}
+	console.log(`   🤖 [Manual Compression] Generating summary from ${toolOutputs.length} tool outputs...`);
+	const summary = (await generateSummary(toolOutputs, model, summaryPrompt, void 0)).trim();
+	if (summary.length === 0) {
+		console.log(`   ⚠️  [Manual Compression] Summary generation returned empty result`);
+		return {
+			summary: "",
+			messageCount: fullMessages.length,
+			toolOutputCount: toolOutputs.length
+		};
+	}
+	console.log(`   ✅ [Manual Compression] Summary generated (${summary.length} chars)`);
+	const existingState = await stateStore.load(sessionId, StateKeys.COMPRESSION);
+	const now = Date.now();
+	const newCompressionState = {
+		lastStats: existingState?.lastStats,
+		history: existingState?.history ?? [],
+		summary,
+		updatedAt: now
+	};
+	await stateStore.save(sessionId, StateKeys.COMPRESSION, newCompressionState);
+	console.log(`   💾 [Manual Compression] Summary saved to CompressionState`);
+	return {
+		summary,
+		messageCount: fullMessages.length,
+		toolOutputCount: toolOutputs.length
+	};
+}
+
+//#endregion
+//#region src/model/base.ts
+/**
+* Abstract base class for LLM model providers.
+*
+* Implement this class to create custom model integrations
+* (e.g., OpenAI, Anthropic, local models).
+*/
+var BaseModel = class {};
+
+//#endregion
+//#region src/model/adapter.ts
+function computeFeatureGrants(options) {
+	const grants = {};
+	const reqs = options.featureRequests || {};
+	for (const [featureId, request] of Object.entries(reqs)) if (options.supportsFeature ? options.supportsFeature(featureId) : false) grants[featureId] = {
+		granted: true,
+		effectiveConfig: request?.config || {}
+	};
+	else grants[featureId] = {
+		granted: false,
+		reason: "feature_not_supported"
+	};
+	return grants;
+}
+
+//#endregion
+//#region src/model/errors.ts
+/**
+* Model error class.
+* Follows SRP: only handles error representation.
+*/
+var ModelError = class extends Error {
+	code;
+	retryable;
+	status;
+	constructor(message, options) {
+		super(message);
+		this.name = "ModelError";
+		this.code = options.code;
+		this.retryable = options.retryable ?? false;
+		this.status = options.status;
+	}
+};
+
+//#endregion
+//#region src/model/health.ts
+/**
+* Model health manager.
+* Follows SRP: only handles health state tracking.
+*/
+var ModelHealth = class {
+	state = /* @__PURE__ */ new Map();
+	get(ref) {
+		return this.state.get(this.keyOf(ref)) || {
+			failures: 0,
+			nextRetryAt: 0
+		};
+	}
+	markSuccess(ref) {
+		this.state.set(this.keyOf(ref), {
+			failures: 0,
+			nextRetryAt: 0
+		});
+	}
+	markFailure(ref, options) {
+		const failures = this.get(ref).failures + 1;
+		const delay = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** Math.min(8, failures - 1));
+		this.state.set(this.keyOf(ref), {
+			failures,
+			nextRetryAt: options.now + delay,
+			lastError: {
+				code: options.code,
+				message: options.message
+			}
+		});
+	}
+	isAvailable(ref, now) {
+		return this.get(ref).nextRetryAt <= now;
+	}
+	keyOf(ref) {
+		return `${ref.provider}:${ref.modelId}`;
+	}
+};
+/**
+* In-memory implementation for backward compatibility.
+*/
+var InMemoryModelHealth = class extends ModelHealth {};
+
+//#endregion
+//#region src/model/router.ts
+/**
+* Model router.
+* Follows SRP: only handles routing logic and fallback selection.
+*/
+var ModelRouter = class {
+	constructor(health, fallbackOrder) {
+		this.health = health;
+		this.fallbackOrder = fallbackOrder;
+	}
+	/**
+	* Select available models based on health and feature requirements.
+	*/
+	select(options) {
+		const { now, requiredFeatures, isFeatureSupported } = options;
+		const available = this.fallbackOrder.filter((ref) => this.health.isAvailable(ref, now));
+		const withFeatures = this.filterByFeatures(available.length ? available : this.fallbackOrder, requiredFeatures, isFeatureSupported);
+		return withFeatures.length ? withFeatures : this.fallbackOrder;
+	}
+	filterByFeatures(candidates, requiredFeatures, isFeatureSupported) {
+		if (!requiredFeatures) return candidates;
+		const requiredIds = Object.entries(requiredFeatures).filter(([, v]) => v?.required).map(([k]) => k);
+		if (!requiredIds.length) return candidates;
+		if (!isFeatureSupported) return [];
+		return candidates.filter((ref) => requiredIds.every((id) => isFeatureSupported(ref, id)));
+	}
+};
+
+//#endregion
+//#region src/model/utils/http.ts
+/**
+* HTTP utility functions.
+* Follows SRP: only handles HTTP-related utilities.
+*/
+var HttpUtils = class {
+	/**
+	* Determine if an HTTP status code is retryable.
+	* Retryable: 408, 409, 429, 5xx
+	*/
+	static isRetryableStatus(status) {
+		return status === 408 || status === 409 || status === 429 || status >= 500 && status <= 599;
+	}
+	/**
+	* Sleep for a specified duration, with abort signal support.
+	*/
+	static async sleep(ms, signal) {
+		if (ms <= 0) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				cleanup();
+				resolve();
+			}, ms);
+			function cleanup() {
+				clearTimeout(timer);
+				if (signal) signal.removeEventListener("abort", onAbort);
+			}
+			function onAbort() {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Aborted"));
+			}
+			if (signal) {
+				if (signal.aborted) return onAbort();
+				signal.addEventListener("abort", onAbort);
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/model/utils/id.ts
+function createRequestId(prefix = "req") {
+	const rand = Math.random().toString(16).slice(2);
+	return `${prefix}_${Date.now().toString(16)}_${rand}`;
+}
+
+//#endregion
+//#region src/model/utils/retry.ts
+/**
+* Retry policy for model requests with exponential backoff and jitter.
+*
+* Implements industry-standard retry patterns:
+* - Exponential backoff: prevents overwhelming recovering services
+* - Jitter: prevents thundering herd when many clients retry simultaneously
+* - Max delay cap: prevents unbounded wait times
+*
+* @example
+* ```ts
+* // Default: exponential backoff with equal jitter
+* const policy = new RetryPolicy()
+*
+* // Custom: 5 attempts, 1s base, 60s max, full jitter
+* const policy = new RetryPolicy({
+*   maxAttempts: 5,
+*   baseDelayMs: 1000,
+*   maxDelayMs: 60000,
+*   jitter: 'full',
+* })
+*
+* // Usage
+* for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+*   try {
+*     await makeRequest()
+*     break
+*   } catch (err) {
+*     if (!policy.canRetry(attempt)) throw err
+*     await sleep(policy.getDelay(attempt))
+*   }
+* }
+* ```
+*/
+var RetryPolicy = class RetryPolicy {
+	maxAttempts;
+	baseDelayMs;
+	maxDelayMs;
+	strategy;
+	jitter;
+	multiplier;
+	_previousDelay;
+	constructor(options = {}) {
+		this.maxAttempts = options.maxAttempts ?? 3;
+		this.baseDelayMs = options.baseDelayMs ?? 500;
+		this.maxDelayMs = options.maxDelayMs ?? 3e4;
+		this.strategy = options.strategy ?? "exponential";
+		this.jitter = options.jitter ?? "equal";
+		this.multiplier = options.multiplier ?? 2;
+		this._previousDelay = this.baseDelayMs;
+	}
+	/**
+	* Calculate delay for a given attempt.
+	*
+	* @param attempt - Current attempt number (1-indexed)
+	* @returns Delay in milliseconds with jitter applied
+	*/
+	getDelay(attempt) {
+		let delay;
+		switch (this.strategy) {
+			case "exponential":
+				delay = this.baseDelayMs * this.multiplier ** (attempt - 1);
+				break;
+			case "linear":
+				delay = this.baseDelayMs * attempt;
+				break;
+			case "fixed":
+				delay = this.baseDelayMs;
+				break;
+		}
+		delay = Math.min(delay, this.maxDelayMs);
+		delay = this.applyJitter(delay);
+		this._previousDelay = delay;
+		return Math.floor(delay);
+	}
+	/**
+	* Apply jitter to the calculated delay.
+	*/
+	applyJitter(delay) {
+		switch (this.jitter) {
+			case "full": return Math.random() * delay;
+			case "equal": return delay / 2 + Math.random() * delay / 2;
+			case "decorrelated": return Math.min(this.maxDelayMs, Math.random() * (this._previousDelay * 3 - this.baseDelayMs) + this.baseDelayMs);
+			case "none":
+			default: return delay;
+		}
+	}
+	/**
+	* Check if another retry is allowed.
+	*
+	* @param attempt - Current attempt number (1-indexed)
+	* @returns true if more retries are allowed
+	*/
+	canRetry(attempt) {
+		return attempt < this.maxAttempts;
+	}
+	/**
+	* Reset internal state (useful for decorrelated jitter).
+	*/
+	reset() {
+		this._previousDelay = this.baseDelayMs;
+	}
+	/**
+	* Get a human-readable description of the policy.
+	*/
+	toString() {
+		return `RetryPolicy(${this.strategy}, max=${this.maxAttempts}, base=${this.baseDelayMs}ms, cap=${this.maxDelayMs}ms, jitter=${this.jitter})`;
+	}
+	/**
+	* Create default retry policy for API calls.
+	* - 3 attempts
+	* - 500ms base delay
+	* - 30s max delay
+	* - Exponential backoff with equal jitter
+	*/
+	static default = new RetryPolicy();
+	/**
+	* Create aggressive retry policy for critical operations.
+	* - 5 attempts
+	* - 1s base delay
+	* - 60s max delay
+	*/
+	static aggressive = new RetryPolicy({
+		maxAttempts: 5,
+		baseDelayMs: 1e3,
+		maxDelayMs: 6e4
+	});
+	/**
+	* Create gentle retry policy for rate-limited APIs.
+	* - 3 attempts
+	* - 2s base delay
+	* - 30s max delay
+	* - Full jitter for better spread
+	*/
+	static gentle = new RetryPolicy({
+		maxAttempts: 3,
+		baseDelayMs: 2e3,
+		maxDelayMs: 3e4,
+		jitter: "full"
+	});
+};
+
+//#endregion
+//#region src/model/createModel.ts
+function createModel(options) {
+	const adapterByProvider = new Map(options.adapters.map((a) => [a.provider, a]));
+	const health = options.health ?? new InMemoryModelHealth();
+	const initialFallbackOrder = options.routing?.fallbackOrder ?? (() => {
+		const derived = [];
+		for (const adapter of options.adapters) if (adapter.defaultModelId) derived.push({
+			provider: adapter.provider,
+			modelId: adapter.defaultModelId
+		});
+		if (derived.length === 0) throw new ModelError("No routing configuration and no adapter with defaultModelId provided. Either provide options.routing.fallbackOrder or set defaultModelId on your adapters.", {
+			code: "missing_routing",
+			retryable: false
+		});
+		return derived;
+	})();
+	const router = new ModelRouter(health, initialFallbackOrder);
+	const retryPolicy = new RetryPolicy({
+		maxAttempts: options.retry?.maxAttemptsPerModel ?? 3,
+		baseDelayMs: options.retry?.baseDelayMs ?? 500,
+		maxDelayMs: options.retry?.maxDelayMs ?? 3e4,
+		strategy: options.retry?.strategy ?? "exponential",
+		jitter: options.retry?.jitter ?? "equal"
+	});
+	const defaultTimeoutMs = options.timeoutMs ?? 6e4;
+	function getAdapter(ref) {
+		const adapter = adapterByProvider.get(ref.provider);
+		if (!adapter) throw new ModelError(`No adapter for provider: ${ref.provider}`, {
+			code: "adapter_missing",
+			retryable: false
+		});
+		return adapter;
+	}
+	function isFeatureSupported(ref, featureId) {
+		const adapter = adapterByProvider.get(ref.provider);
+		if (!adapter?.supportsFeature) return false;
+		return adapter.supportsFeature(ref.modelId, featureId);
+	}
+	async function* stream(requestIn) {
+		const now = Date.now();
+		const requestId = requestIn.requestId || createRequestId("req");
+		const order = requestIn.model ? [requestIn.model] : router.select({
+			now,
+			requiredFeatures: requestIn.features,
+			isFeatureSupported
+		});
+		let lastError;
+		const toolCallAccumulator = /* @__PURE__ */ new Map();
+		for (const modelRef of order) {
+			const adapter = getAdapter(modelRef);
+			const timeoutMs = requestIn.timeoutMs ?? defaultTimeoutMs;
+			const featureGrants = computeFeatureGrants({
+				modelId: modelRef.modelId,
+				featureRequests: requestIn.features,
+				supportsFeature: (fid) => adapter.supportsFeature?.(modelRef.modelId, fid) ?? false
+			});
+			if (Object.entries(requestIn.features || {}).some(([fid, req$1]) => req$1?.required && !featureGrants[fid]?.granted)) continue;
+			const controller = new AbortController();
+			const signal = requestIn.signal;
+			const timeout = setTimeout(() => controller.abort(), timeoutMs);
+			const abortListener = () => controller.abort();
+			if (signal) if (signal.aborted) controller.abort();
+			else signal.addEventListener("abort", abortListener);
+			const req = {
+				requestId,
+				model: modelRef,
+				input: requestIn.input,
+				messages: requestIn.messages,
+				tools: requestIn.tools,
+				features: requestIn.features,
+				stream: requestIn.stream ?? true,
+				signal: controller.signal,
+				timeoutMs
+			};
+			try {
+				for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) try {
+					for await (const ev of adapter.stream({
+						request: req,
+						featureGrants,
+						featureRequests: requestIn.features
+					})) if (ev.type === "delta") {
+						if (ev.chunk.kind === "text") yield {
+							type: "text_delta",
+							delta: ev.chunk.text
+						};
+						else if (ev.chunk.kind === "thinking_delta") yield {
+							type: ev.chunk.kind,
+							content: ev.chunk.text
+						};
+						else if (ev.chunk.kind === "thinking_end" || ev.chunk.kind === "thinking_start") yield { type: ev.chunk.kind };
+						else if (ev.chunk.kind === "tool_call_delta") {
+							const existing = toolCallAccumulator.get(ev.chunk.callId) ?? { argsText: "" };
+							if (ev.chunk.toolId) existing.toolId = ev.chunk.toolId;
+							if (ev.chunk.argsTextDelta) existing.argsText += ev.chunk.argsTextDelta;
+							toolCallAccumulator.set(ev.chunk.callId, existing);
+						}
+					} else if (ev.type === "response_end") {
+						for (const [callId, data] of toolCallAccumulator) if (data.toolId) yield {
+							type: "tool_call",
+							toolCall: {
+								id: callId,
+								type: "function",
+								function: {
+									name: data.toolId,
+									arguments: data.argsText
+								}
+							}
+						};
+						toolCallAccumulator.clear();
+						if (ev.usage && typeof ev.usage === "object") {
+							const usage = ev.usage;
+							if (usage.prompt_tokens || usage.completion_tokens || usage.total_tokens) yield {
+								type: "usage",
+								usage: {
+									promptTokens: usage.prompt_tokens ?? 0,
+									completionTokens: usage.completion_tokens ?? 0,
+									totalTokens: usage.total_tokens ?? 0
+								}
+							};
+						}
+						yield { type: "done" };
+					} else yield ev;
+					health.markSuccess(modelRef);
+					return;
+				} catch (err) {
+					lastError = err;
+					const modelError = normalizeModelError(err);
+					if (!modelError.retryable || !retryPolicy.canRetry(attempt)) throw modelError;
+					const delayMs = retryPolicy.getDelay(attempt);
+					options.retry?.onRetry?.({
+						attempt,
+						maxAttempts: retryPolicy.maxAttempts,
+						delayMs,
+						error: {
+							code: modelError.code,
+							message: modelError.message,
+							retryable: modelError.retryable
+						},
+						model: modelRef,
+						request: req
+					});
+					await HttpUtils.sleep(delayMs, controller.signal);
+				}
+			} catch (err) {
+				const modelError = normalizeModelError(err);
+				health.markFailure(modelRef, {
+					now: Date.now(),
+					baseDelayMs: retryPolicy.baseDelayMs,
+					maxDelayMs: retryPolicy.maxDelayMs,
+					code: modelError.code,
+					message: modelError.message
+				});
+				yield {
+					type: "error",
+					requestId,
+					error: {
+						code: modelError.code,
+						message: modelError.message,
+						retryable: modelError.retryable
+					}
+				};
+				lastError = modelError;
+				continue;
+			} finally {
+				clearTimeout(timeout);
+				if (signal) signal.removeEventListener("abort", abortListener);
+			}
+		}
+		throw normalizeModelError(lastError || new ModelError("All models failed", { code: "all_models_failed" }));
+	}
+	async function run(request) {
+		let text = "";
+		let stopReason = "error";
+		let usage;
+		let model;
+		let requestId = request.requestId || "";
+		let featureGrants = {};
+		for await (const ev of stream({
+			...request,
+			stream: true
+		})) if (ev.type === "response_start") {
+			requestId = ev.requestId;
+			model = ev.model;
+			featureGrants = ev.featureGrants;
+		} else if (ev.type === "delta" && ev.chunk.kind === "text") text += ev.chunk.text;
+		else if (ev.type === "text_delta") text += ev.delta;
+		else if (ev.type === "response_end") {
+			stopReason = ev.stopReason;
+			usage = ev.usage;
+		} else if (ev.type === "error") stopReason = "error";
+		if (!model) throw new ModelError("Missing response_start from adapter", {
+			code: "protocol_error",
+			retryable: false
+		});
+		return {
+			requestId,
+			model,
+			text,
+			stopReason,
+			usage,
+			featureGrants
+		};
+	}
+	return {
+		get modelId() {
+			return initialFallbackOrder[0]?.modelId ?? "unknown";
+		},
+		setModelId(modelId) {
+			const primary = initialFallbackOrder[0];
+			if (!primary) throw new ModelError("No primary model to update", {
+				code: "no_primary_model",
+				retryable: false
+			});
+			initialFallbackOrder[0] = {
+				provider: primary.provider,
+				modelId
+			};
+		},
+		invoke: async (messages, options$1) => {
+			const result = await run({
+				messages,
+				tools: options$1?.tools
+			});
+			return {
+				message: {
+					role: "assistant",
+					content: result.text
+				},
+				usage: result.usage
+			};
+		},
+		stream: ((messagesOrRequest, options$1) => {
+			if (Array.isArray(messagesOrRequest)) return stream({
+				messages: messagesOrRequest,
+				tools: options$1?.tools
+			});
+			return stream(messagesOrRequest);
+		}),
+		run
+	};
+}
+function normalizeModelError(err) {
+	if (err instanceof ModelError) return err;
+	if (err && typeof err === "object") {
+		const status = typeof err.status === "number" ? err.status : void 0;
+		const code = typeof err.code === "string" ? err.code : status ? `http_${status}` : "unknown_error";
+		return new ModelError(typeof err.message === "string" ? err.message : "Unknown error", {
+			code,
+			retryable: status ? HttpUtils.isRetryableStatus(status) : false,
+			status
+		});
+	}
+	return new ModelError(String(err || "Unknown error"), {
+		code: "unknown_error",
+		retryable: false
+	});
+}
+
+//#endregion
+//#region src/model/openai/createOpenAIAdapter.ts
+/**
+* Convert Message content to OpenAI format
+* Handles string, ContentBlock, and ContentBlock[]
+*/
+function toOpenAIContent(content) {
+	if (typeof content === "string") return content.trim().length === 0 ? "" : content;
+	if (content === null || content === void 0) return "";
+	if (typeof content === "object" && "type" in content) {
+		const block = content;
+		if (block.type === "text" && block.text) return block.text;
+		if (block.type === "image" && block.source?.data) return [{
+			type: "image_url",
+			image_url: { url: block.source.data }
+		}];
+	}
+	if (Array.isArray(content)) {
+		const result = [];
+		for (const item of content) if (typeof item === "string") result.push({
+			type: "text",
+			text: item
+		});
+		else if (item && typeof item === "object" && "type" in item) {
+			const block = item;
+			if (block.type === "text" && block.text) result.push({
+				type: "text",
+				text: block.text
+			});
+			else if (block.type === "image" && block.source?.data) result.push({
+				type: "image_url",
+				image_url: { url: block.source.data }
+			});
+		}
+		return result.length > 0 ? result : "";
+	}
+	return String(content);
+}
+/**
+* Convert Message to OpenAI format.
+*
+* The main conversion is for the `content` field, which may be in MCP format
+* (ContentBlock) and needs to be converted to OpenAI format (string or array).
+* Other fields like tool_call_id and tool_calls are already OpenAI-compatible.
+*/
+function toOpenAIMessage(message) {
+	return {
+		...message,
+		content: toOpenAIContent(message.content)
+	};
+}
+function createOpenAIAdapter(options = {}) {
+	const baseUrl = options.baseUrl;
+	const apiKeySecretName = options.apiKeySecretName || "OPENAI_API_KEY";
+	const secretProvider = options.secretProvider;
+	function getApiKey() {
+		const key = secretProvider?.get(apiKeySecretName);
+		if (!key) throw new ModelError(`Missing secret: ${apiKeySecretName}`, {
+			code: "missing_api_key",
+			retryable: false
+		});
+		return key;
+	}
+	function createClient() {
+		const apiKey = getApiKey();
+		if (typeof baseUrl === "string" && /\/chat\/completions\/?$/.test(baseUrl)) return new OpenAI({
+			apiKey,
+			organization: options.organization,
+			project: options.project,
+			baseURL: "https://api.openai.com/v1",
+			fetch: (input, init) => {
+				return fetch(baseUrl, init);
+			}
+		});
+		return new OpenAI({
+			apiKey,
+			organization: options.organization,
+			project: options.project,
+			baseURL: baseUrl || void 0
+		});
+	}
+	function toModelRef(request) {
+		return {
+			provider: "openai",
+			modelId: request.model.modelId
+		};
+	}
+	function toModelError(err) {
+		if (err instanceof ModelError) return err;
+		const status = typeof err?.status === "number" ? err.status : void 0;
+		return new ModelError(typeof err?.message === "string" ? err.message : "OpenAI error", {
+			code: typeof err?.code === "string" ? err.code : status ? `openai_http_${status}` : "openai_error",
+			retryable: status ? HttpUtils.isRetryableStatus(status) : false,
+			status
+		});
+	}
+	function supportsFeature(_modelId, _featureId) {
+		return false;
+	}
+	async function* stream(args) {
+		const { request, featureGrants } = args;
+		const requestId = request.requestId || createRequestId("req");
+		const client = createClient();
+		const model = request.model.modelId;
+		const shouldStream = request.stream !== false;
+		const messages = [];
+		if (request.messages && Array.isArray(request.messages)) messages.push(...request.messages.map(toOpenAIMessage));
+		else {
+			if (typeof request.instructions === "string" && request.instructions.length > 0) messages.push({
+				role: "system",
+				content: request.instructions
+			});
+			messages.push({
+				role: "user",
+				content: request.input
+			});
+		}
+		const reasoningEffort = (() => {
+			const effort = request.reasoning?.effort;
+			if (typeof effort !== "string") return void 0;
+			if (effort === "none" || effort === "minimal" || effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh") return effort;
+		})();
+		const body = {
+			model,
+			messages,
+			stream: shouldStream,
+			stream_options: shouldStream ? { include_usage: true } : void 0,
+			metadata: request.metadata ?? void 0,
+			reasoning_effort: reasoningEffort,
+			max_completion_tokens: request.maxOutputTokens ?? void 0,
+			temperature: request.temperature ?? void 0,
+			top_p: request.topP ?? void 0,
+			presence_penalty: request.presencePenalty ?? void 0,
+			frequency_penalty: request.frequencyPenalty ?? void 0,
+			seed: request.seed ?? void 0
+		};
+		if (request.tools && Array.isArray(request.tools) && request.tools.length > 0) body.tools = request.tools;
+		try {
+			yield {
+				type: "response_start",
+				requestId,
+				model: toModelRef(request),
+				featureGrants
+			};
+			if (!shouldStream) {
+				const resp = await client.chat.completions.create({
+					...body,
+					stream: false
+				}, {
+					signal: request.signal,
+					timeout: request.timeoutMs
+				});
+				const choice = Array.isArray(resp?.choices) ? resp.choices[0] : void 0;
+				const message = choice?.message;
+				const reasoningContent = typeof message?.reasoning_content === "string" ? message.reasoning_content : "";
+				if (reasoningContent.length > 0) {
+					yield {
+						type: "delta",
+						requestId,
+						chunk: { kind: "thinking_start" }
+					};
+					yield {
+						type: "delta",
+						requestId,
+						chunk: {
+							kind: "thinking_delta",
+							text: reasoningContent
+						}
+					};
+					yield {
+						type: "delta",
+						requestId,
+						chunk: { kind: "thinking_end" }
+					};
+				}
+				const text = typeof message?.content === "string" ? message.content : "";
+				if (text.length > 0) yield {
+					type: "delta",
+					requestId,
+					chunk: {
+						kind: "text",
+						text
+					}
+				};
+				const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+				for (let i = 0; i < toolCalls.length; i++) {
+					const tc = toolCalls[i];
+					const callId = typeof tc?.id === "string" ? tc.id : `call_${i}`;
+					const toolId = typeof tc?.function?.name === "string" ? tc.function.name : void 0;
+					const args$1 = typeof tc?.function?.arguments === "string" ? tc.function.arguments : void 0;
+					if (args$1 || toolId) yield {
+						type: "delta",
+						requestId,
+						chunk: {
+							kind: "tool_call_delta",
+							callId,
+							toolId,
+							argsTextDelta: args$1
+						}
+					};
+				}
+				yield {
+					type: "response_end",
+					requestId,
+					stopReason: toStopReason(choice?.finish_reason),
+					usage: resp?.usage
+				};
+				return;
+			}
+			const stream$1 = await client.chat.completions.create({
+				...body,
+				stream: true
+			}, {
+				signal: request.signal,
+				timeout: request.timeoutMs
+			});
+			let finishReason = null;
+			let lastUsage = void 0;
+			const callIdByIndex = /* @__PURE__ */ new Map();
+			let inThinkingPhase = false;
+			for await (const chunk of stream$1) {
+				if (chunk?.usage != null) lastUsage = chunk.usage;
+				const choices = Array.isArray(chunk?.choices) ? chunk.choices : [];
+				for (const choice of choices) {
+					if (choice?.finish_reason != null) finishReason = choice.finish_reason;
+					const delta = choice?.delta;
+					const reasoningContent = delta?.reasoning_content;
+					if (typeof reasoningContent === "string" && reasoningContent.length > 0) {
+						if (!inThinkingPhase) {
+							inThinkingPhase = true;
+							yield {
+								type: "delta",
+								requestId,
+								chunk: { kind: "thinking_start" }
+							};
+						}
+						yield {
+							type: "delta",
+							requestId,
+							chunk: {
+								kind: "thinking_delta",
+								text: reasoningContent
+							}
+						};
+					}
+					const content = delta?.content;
+					if (typeof content === "string" && content.length > 0) {
+						if (inThinkingPhase) {
+							inThinkingPhase = false;
+							yield {
+								type: "delta",
+								requestId,
+								chunk: { kind: "thinking_end" }
+							};
+						}
+						yield {
+							type: "delta",
+							requestId,
+							chunk: {
+								kind: "text",
+								text: content
+							}
+						};
+					}
+					const toolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
+					for (const tc of toolCalls) {
+						const index = typeof tc?.index === "number" ? tc.index : 0;
+						const callId = callIdByIndex.get(index) || (typeof tc?.id === "string" ? tc.id : `call_${index}`);
+						callIdByIndex.set(index, callId);
+						const toolId = typeof tc?.function?.name === "string" ? tc.function.name : void 0;
+						const argsDelta = typeof tc?.function?.arguments === "string" ? tc.function.arguments : void 0;
+						if (toolId || argsDelta) yield {
+							type: "delta",
+							requestId,
+							chunk: {
+								kind: "tool_call_delta",
+								callId,
+								toolId,
+								argsTextDelta: argsDelta
+							}
+						};
+					}
+				}
+			}
+			if (inThinkingPhase) yield {
+				type: "delta",
+				requestId,
+				chunk: { kind: "thinking_end" }
+			};
+			yield {
+				type: "response_end",
+				requestId,
+				stopReason: toStopReason(finishReason),
+				usage: lastUsage
+			};
+		} catch (err) {
+			if (err?.name === "AbortError") throw new ModelError("Aborted", {
+				code: "aborted",
+				retryable: false
+			});
+			throw toModelError(err);
+		}
+	}
+	return {
+		provider: "openai",
+		defaultModelId: options.defaultModelId,
+		supportsFeature,
+		stream
+	};
+}
+function toStopReason(finishReason) {
+	if (finishReason === "tool_calls" || finishReason === "function_call") return "tool_call";
+	if (finishReason === "length") return "length";
+	if (finishReason === "content_filter") return "error";
+	if (finishReason === "stop" || finishReason == null) return "final";
+	return "final";
+}
+
+//#endregion
+//#region src/session/base.ts
+/**
+* Abstract base class for a session.
+*
+* A session represents a single conversation instance with an agent.
+* One agent can have multiple concurrent sessions.
+*/
+var BaseSession = class {
+	/**
+	* Set model override for this session
+	*
+	* @param model - Model configuration to use for this session
+	*/
+	setModelOverride(model) {
+		if (!this.configOverride) this.configOverride = {};
+		this.configOverride.model = model;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Clear model override (use agent's default model)
+	*/
+	clearModelOverride() {
+		if (this.configOverride) {
+			delete this.configOverride.model;
+			this.updatedAt = Date.now();
+		}
+	}
+	/**
+	* Set system prompt override for this session
+	*
+	* @param systemPrompt - System prompt to use for this session
+	*/
+	setSystemPromptOverride(systemPrompt) {
+		if (!this.configOverride) this.configOverride = {};
+		this.configOverride.systemPromptOverride = systemPrompt;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Clear system prompt override
+	*/
+	clearSystemPromptOverride() {
+		if (this.configOverride) {
+			delete this.configOverride.systemPromptOverride;
+			this.updatedAt = Date.now();
+		}
+	}
+	/**
+	* Disable specific tools for this session
+	*
+	* @param toolNames - Names of tools to disable
+	*/
+	disableTools(toolNames) {
+		if (!this.configOverride) this.configOverride = {};
+		this.configOverride.disabledTools = [...this.configOverride.disabledTools ?? [], ...toolNames];
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Re-enable all tools for this session
+	*/
+	enableAllTools() {
+		if (this.configOverride) {
+			delete this.configOverride.disabledTools;
+			this.updatedAt = Date.now();
+		}
+	}
+	/**
+	* Update session status
+	*
+	* @param status - New status
+	* @param errorMessage - Error message (if status is 'error')
+	*/
+	setStatus(status, errorMessage) {
+		this.status = status;
+		this.errorMessage = errorMessage;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Mark session as active (update lastActiveAt)
+	*/
+	markActive() {
+		this.lastActiveAt = Date.now();
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Add a message to the conversation history
+	*
+	* @param message - Message to add
+	*/
+	addMessage(message) {
+		this.messages.push(message);
+		this.markActive();
+	}
+	/**
+	* Get preview of the last message (truncated for display)
+	*
+	* @param maxLength - Maximum length of preview
+	* @returns Preview string or undefined if no messages
+	*/
+	getLastMessagePreview(maxLength = 100) {
+		if (this.messages.length === 0) return void 0;
+		const lastMessage = this.messages[this.messages.length - 1];
+		const content = typeof lastMessage.content === "string" ? lastMessage.content : JSON.stringify(lastMessage.content);
+		return content.length > maxLength ? `${content.substring(0, maxLength)}...` : content;
+	}
+	/**
+	* Add usage statistics
+	*
+	* @param usage - Usage to add
+	* @param usage.promptTokens - Number of prompt tokens
+	* @param usage.completionTokens - Number of completion tokens
+	* @param usage.totalTokens - Total number of tokens
+	*/
+	addUsage(usage) {
+		this.usage.promptTokens += usage.promptTokens;
+		this.usage.completionTokens += usage.completionTokens;
+		this.usage.totalTokens += usage.totalTokens;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Record a response with its duration
+	*
+	* @param durationMs - Response duration in milliseconds
+	*/
+	recordResponse(durationMs) {
+		const currentTotal = (this.avgResponseTime ?? 0) * this.responseCount;
+		this.responseCount++;
+		this.avgResponseTime = (currentTotal + durationMs) / this.responseCount;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Increment tool call count
+	*/
+	incrementToolCallCount() {
+		this.toolCallCount++;
+		this.updatedAt = Date.now();
+	}
+	/**
+	* Create a snapshot of the session for persistence
+	*
+	* @returns Session snapshot
+	*/
+	toSnapshot() {
+		const state = {
+			status: this.status,
+			updatedAt: this.updatedAt,
+			lastActiveAt: this.lastActiveAt,
+			title: this.title,
+			errorMessage: this.errorMessage
+		};
+		const context = {
+			messages: [...this.messages],
+			messageCount: this.messages.length,
+			lastMessagePreview: this.getLastMessagePreview(),
+			toolCallCount: this.toolCallCount
+		};
+		const stats = {
+			usage: { ...this.usage },
+			responseCount: this.responseCount,
+			avgResponseTime: this.avgResponseTime
+		};
+		return {
+			id: this.id,
+			agentId: this.agentId,
+			createdAt: this.createdAt,
+			state,
+			configOverride: this.configOverride ? { ...this.configOverride } : void 0,
+			context,
+			stats,
+			metadata: this.metadata ? { ...this.metadata } : void 0
+		};
+	}
+	/**
+	* Restore session state from a snapshot
+	*
+	* @param snapshot - Session snapshot to restore from
+	*/
+	restoreFromSnapshot(snapshot) {
+		this.status = snapshot.state.status;
+		this.updatedAt = snapshot.state.updatedAt;
+		this.lastActiveAt = snapshot.state.lastActiveAt;
+		this.title = snapshot.state.title;
+		this.errorMessage = snapshot.state.errorMessage;
+		this.configOverride = snapshot.configOverride ? { ...snapshot.configOverride } : void 0;
+		this.messages = [...snapshot.context.messages];
+		this.toolCallCount = snapshot.context.toolCallCount;
+		this.usage = { ...snapshot.stats.usage };
+		this.responseCount = snapshot.stats.responseCount;
+		this.avgResponseTime = snapshot.stats.avgResponseTime;
+		this.metadata = snapshot.metadata ? { ...snapshot.metadata } : {};
+	}
+};
+
+//#endregion
+//#region src/session/manager.ts
+/**
+* Abstract base class for session management.
+*
+* Handles session lifecycle: creation, retrieval, listing, and destruction.
+* Implement this class for different storage backends (e.g., Redis, SQLite, in-memory).
+*/
+var BaseSessionManager = class {};
+
+//#endregion
+//#region src/tool/base.ts
+/**
+* Helper to create a text content block for CallToolResult
+*/
+function textContent(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+/**
+* Helper to create an error result for CallToolResult
+*/
+function errorContent(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error
+		}],
+		isError: true
+	};
+}
+/**
+* Helper to create an image content block for CallToolResult
+*/
+function imageContent(data, mimeType) {
+	return { content: [{
+		type: "image",
+		data,
+		mimeType
+	}] };
+}
+/**
+* Abstract base class for tools.
+*
+* Tools are capabilities that the agent can invoke during execution.
+* Implement this class to create custom tools.
+*
+* All tool execute() methods must return MCP SDK-compliant CallToolResult:
+* - content: array of ContentBlock (TextContent, ImageContent, etc.)
+* - isError: optional boolean to indicate error
+* - structuredContent: optional structured data object
+*/
+var BaseTool = class {
+	/**
+	* Risk level of the tool, used to determine if user approval is required.
+	*
+	* - 'safe': No risk, read-only operations (default)
+	* - 'low': Low risk, minimal side effects
+	* - 'medium': Medium risk, reversible changes
+	* - 'high': High risk, file modifications
+	* - 'critical': Critical risk, arbitrary command execution
+	*/
+	riskLevel = "safe";
+};
+
+//#endregion
+//#region src/tool/builtin/glob.ts
+/**
+* Maximum number of files to return
+*/
+const MAX_FILES = 1e3;
+/**
+* Maximum depth for recursive search
+*/
+const MAX_DEPTH = 20;
+/**
+* Convert glob pattern to RegExp
+*
+* Supports:
+* - `*` matches any sequence of characters except `/`
+* - `**` matches any sequence of characters including `/`
+* - `?` matches any single character except `/`
+* - `{a,b}` matches either `a` or `b`
+* - `[abc]` matches any character in the brackets
+*/
+function globToRegex(pattern) {
+	let regexStr = "";
+	let i = 0;
+	while (i < pattern.length) {
+		const char = pattern[i];
+		if (char === "*") if (pattern[i + 1] === "*") if (pattern[i + 2] === "/") {
+			regexStr += "(?:.*\\/)?";
+			i += 3;
+		} else {
+			regexStr += ".*";
+			i += 2;
+		}
+		else {
+			regexStr += "[^/]*";
+			i++;
+		}
+		else if (char === "?") {
+			regexStr += "[^/]";
+			i++;
+		} else if (char === "{") {
+			const end = pattern.indexOf("}", i);
+			if (end !== -1) {
+				const options = pattern.slice(i + 1, end).split(",");
+				regexStr += `(?:${options.map((o) => escapeRegex(o)).join("|")})`;
+				i = end + 1;
+			} else {
+				regexStr += "\\{";
+				i++;
+			}
+		} else if (char === "[") {
+			const end = pattern.indexOf("]", i);
+			if (end !== -1) {
+				regexStr += pattern.slice(i, end + 1);
+				i = end + 1;
+			} else {
+				regexStr += "\\[";
+				i++;
+			}
+		} else if (char === ".") {
+			regexStr += "\\.";
+			i++;
+		} else if (char === "/") {
+			regexStr += "\\/";
+			i++;
+		} else if ("()[]{}^$+|\\".includes(char)) {
+			regexStr += `\\${char}`;
+			i++;
+		} else {
+			regexStr += char;
+			i++;
+		}
+	}
+	return /* @__PURE__ */ new RegExp(`^${regexStr}$`);
+}
+/**
+* Escape special regex characters
+*/
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Tool for finding files matching glob patterns.
+*
+* This tool provides fast file pattern matching that works with any codebase size,
+* returning matching file paths sorted by modification time.
+*
+* @example
+* ```typescript
+* const globTool = new GlobTool()
+* const result = await globTool.execute({
+*   pattern: '**\/*.ts',
+*   path: './src'
+* })
+* ```
+*/
+var GlobTool = class extends BaseTool {
+	name = "Glob";
+	description = `Fast file pattern matching tool that works with any codebase size.
+
+Usage notes:
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time (newest first)
+- Use this tool when you need to find files by name patterns
+- You can call multiple tools in a single response for parallel searches
+
+Supported patterns:
+- \`*\` matches any sequence of characters except path separator
+- \`**\` matches any sequence of characters including path separator
+- \`?\` matches any single character
+- \`{a,b}\` matches either a or b
+- \`[abc]\` matches any character in brackets`;
+	parameters = {
+		type: "object",
+		properties: {
+			pattern: {
+				type: "string",
+				description: "The glob pattern to match files against"
+			},
+			path: {
+				type: "string",
+				description: "The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior."
+			}
+		},
+		required: ["pattern"]
+	};
+	/** Current working directory for search */
+	cwd;
+	constructor(options) {
+		super();
+		this.cwd = options?.cwd ?? process.cwd();
+	}
+	/**
+	* Set the current working directory
+	*/
+	setCwd(cwd) {
+		this.cwd = cwd;
+	}
+	/**
+	* Get the current working directory
+	*/
+	getCwd() {
+		return this.cwd;
+	}
+	/**
+	* Execute glob pattern matching
+	*
+	* @param args - Glob arguments
+	* @returns MCP-compliant CallToolResult with matching files
+	*/
+	async execute(args) {
+		const { pattern, path: searchPath } = this.validateArgs(args);
+		const baseDir = searchPath ? path.isAbsolute(searchPath) ? searchPath : path.resolve(this.cwd, searchPath) : this.cwd;
+		try {
+			if (!(await stat(baseDir)).isDirectory()) return errorContent(`Path is not a directory: ${baseDir}`);
+		} catch (error) {
+			if (error.code === "ENOENT") return errorContent(`Directory not found: ${baseDir}`);
+			throw error;
+		}
+		let normalizedPattern = pattern;
+		if (!pattern.startsWith("**/") && !pattern.startsWith("/") && !pattern.startsWith("./")) normalizedPattern = `**/${pattern}`;
+		const regex = globToRegex(normalizedPattern);
+		const files = [];
+		await this.walkDirectory(baseDir, "", regex, files, 0);
+		files.sort((a, b) => b.mtime - a.mtime);
+		const truncated = files.length > MAX_FILES;
+		const resultFiles = files.slice(0, MAX_FILES).map((f) => f.path);
+		const result = {
+			files: resultFiles,
+			totalMatches: files.length,
+			truncated
+		};
+		return {
+			content: [{
+				type: "text",
+				text: resultFiles.length > 0 ? `Found ${files.length} file${files.length !== 1 ? "s" : ""}${truncated ? ` (showing first ${MAX_FILES})` : ""}:\n${resultFiles.join("\n")}` : `No files found matching pattern: ${pattern}`
+			}],
+			structuredContent: result
+		};
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const pattern = args.pattern;
+		if (typeof pattern !== "string" || !pattern.trim()) throw new Error("Pattern is required and must be a non-empty string");
+		let searchPath;
+		if (args.path !== void 0 && args.path !== null && args.path !== "undefined" && args.path !== "null") {
+			if (typeof args.path !== "string") throw new TypeError("Path must be a string");
+			searchPath = args.path.trim() || void 0;
+		}
+		return {
+			pattern: pattern.trim(),
+			path: searchPath
+		};
+	}
+	/**
+	* Recursively walk directory and collect matching files
+	*/
+	async walkDirectory(baseDir, relativePath, pattern, files, depth) {
+		if (depth > MAX_DEPTH) return;
+		const currentDir = relativePath ? path.join(baseDir, relativePath) : baseDir;
+		let entries;
+		try {
+			entries = await readdir(currentDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) await this.walkDirectory(baseDir, entryRelativePath, pattern, files, depth + 1);
+			else if (entry.isFile()) {
+				if (pattern.test(entryRelativePath)) try {
+					const stats = await stat(path.join(currentDir, entry.name));
+					files.push({
+						path: entryRelativePath,
+						mtime: stats.mtimeMs
+					});
+				} catch {}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/tool/builtin/grep.ts
+/**
+* Maximum output length before truncation (in characters)
+*/
+const MAX_OUTPUT_LENGTH = 5e4;
+/**
+* Default command timeout (60 seconds)
+*/
+const DEFAULT_TIMEOUT = 6e4;
+/**
+* Tool for searching files using ripgrep.
+*
+* A powerful search tool built on ripgrep that supports regex patterns,
+* multiple output modes, and various filtering options.
+*
+* @example
+* ```typescript
+* const grepTool = new GrepTool()
+* const result = await grepTool.execute({
+*   pattern: 'function\\s+\\w+',
+*   path: './src',
+*   type: 'ts'
+* })
+* ```
+*/
+var GrepTool = class extends BaseTool {
+	name = "Grep";
+	description = `A powerful search tool built on ripgrep.
+
+Usage notes:
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+- Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+- Multiline matching: By default patterns match within single lines only. For cross-line patterns, use multiline: true`;
+	parameters = {
+		type: "object",
+		properties: {
+			pattern: {
+				type: "string",
+				description: "The regular expression pattern to search for in file contents"
+			},
+			path: {
+				type: "string",
+				description: "File or directory to search in. Defaults to current working directory."
+			},
+			glob: {
+				type: "string",
+				description: "Glob pattern to filter files (e.g. \"*.js\", \"*.{ts,tsx}\")"
+			},
+			output_mode: {
+				type: "string",
+				enum: [
+					"content",
+					"files_with_matches",
+					"count"
+				],
+				description: "Output mode: \"content\" shows matching lines, \"files_with_matches\" shows file paths (default), \"count\" shows match counts."
+			},
+			"-B": {
+				type: "number",
+				description: "Number of lines to show before each match. Requires output_mode: \"content\"."
+			},
+			"-A": {
+				type: "number",
+				description: "Number of lines to show after each match. Requires output_mode: \"content\"."
+			},
+			"-C": {
+				type: "number",
+				description: "Number of lines to show before and after each match. Requires output_mode: \"content\"."
+			},
+			"-n": {
+				type: "boolean",
+				description: "Show line numbers in output. Requires output_mode: \"content\". Defaults to true."
+			},
+			"-i": {
+				type: "boolean",
+				description: "Case insensitive search"
+			},
+			type: {
+				type: "string",
+				description: "File type to search (e.g., js, py, rust, go, java). More efficient than glob for standard file types."
+			},
+			head_limit: {
+				type: "number",
+				description: "Limit output to first N lines/entries. Defaults to 0 (unlimited)."
+			},
+			offset: {
+				type: "number",
+				description: "Skip first N lines/entries before applying head_limit. Defaults to 0."
+			},
+			multiline: {
+				type: "boolean",
+				description: "Enable multiline mode where . matches newlines and patterns can span lines. Default: false."
+			}
+		},
+		required: ["pattern"]
+	};
+	/** Current working directory for search */
+	cwd;
+	/** Path to ripgrep binary */
+	rgPath;
+	constructor(options) {
+		super();
+		this.cwd = options?.cwd ?? process.cwd();
+		this.rgPath = options?.rgPath ?? "rg";
+	}
+	/**
+	* Set the current working directory
+	*/
+	setCwd(cwd) {
+		this.cwd = cwd;
+	}
+	/**
+	* Get the current working directory
+	*/
+	getCwd() {
+		return this.cwd;
+	}
+	/**
+	* Execute grep search
+	*
+	* @param args - Grep arguments
+	* @returns MCP-compliant CallToolResult with search results
+	*/
+	async execute(args) {
+		const validatedArgs = this.validateArgs(args);
+		const rgArgs = this.buildRgArgs(validatedArgs);
+		const result = await this.runRipgrep(rgArgs, validatedArgs);
+		let text = result.output || "[No matches found]";
+		if (result.timedOut) text += "\n[Search timed out]";
+		if (result.matchCount !== void 0) text = `Found ${result.matchCount} match${result.matchCount !== 1 ? "es" : ""}\n${text}`;
+		return {
+			content: [{
+				type: "text",
+				text
+			}],
+			structuredContent: result,
+			isError: result.exitCode !== 0 && result.exitCode !== 1
+		};
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const pattern = args.pattern;
+		if (typeof pattern !== "string" || !pattern.trim()) throw new Error("Pattern is required and must be a non-empty string");
+		const result = { pattern: pattern.trim() };
+		if (args.path !== void 0 && args.path !== null && args.path !== "") {
+			if (typeof args.path !== "string") throw new TypeError("Path must be a string");
+			result.path = args.path.trim();
+		}
+		if (args.glob !== void 0 && args.glob !== null && args.glob !== "") {
+			if (typeof args.glob !== "string") throw new TypeError("Glob must be a string");
+			result.glob = args.glob.trim();
+		}
+		if (args.type !== void 0 && args.type !== null && args.type !== "") {
+			if (typeof args.type !== "string") throw new TypeError("Type must be a string");
+			result.type = args.type.trim();
+		}
+		if (args.output_mode !== void 0) {
+			const validModes = [
+				"content",
+				"files_with_matches",
+				"count"
+			];
+			if (!validModes.includes(args.output_mode)) throw new Error(`Invalid output_mode. Must be one of: ${validModes.join(", ")}`);
+			result.output_mode = args.output_mode;
+		}
+		for (const arg of [
+			"-B",
+			"-A",
+			"-C",
+			"head_limit",
+			"offset"
+		]) if (args[arg] !== void 0 && args[arg] !== null) {
+			if (typeof args[arg] !== "number") throw new TypeError(`${arg} must be a number`);
+			result[arg] = Math.max(0, Math.floor(args[arg]));
+		}
+		for (const arg of [
+			"-n",
+			"-i",
+			"multiline"
+		]) if (args[arg] !== void 0 && args[arg] !== null) result[arg] = Boolean(args[arg]);
+		return result;
+	}
+	/**
+	* Build ripgrep command arguments
+	*/
+	buildRgArgs(args) {
+		const rgArgs = [];
+		const outputMode = args.output_mode ?? "files_with_matches";
+		if (outputMode === "files_with_matches") rgArgs.push("-l");
+		else if (outputMode === "count") rgArgs.push("-c");
+		if (outputMode === "content") {
+			if (args["-n"] !== false) rgArgs.push("-n");
+			if (args["-B"] !== void 0 && args["-B"] > 0) rgArgs.push("-B", String(args["-B"]));
+			if (args["-A"] !== void 0 && args["-A"] > 0) rgArgs.push("-A", String(args["-A"]));
+			if (args["-C"] !== void 0 && args["-C"] > 0) rgArgs.push("-C", String(args["-C"]));
+		}
+		if (args["-i"]) rgArgs.push("-i");
+		if (args.multiline) rgArgs.push("-U", "--multiline-dotall");
+		if (args.type) rgArgs.push("--type", args.type);
+		if (args.glob) rgArgs.push("--glob", args.glob);
+		rgArgs.push("--color", "never");
+		rgArgs.push("--no-heading");
+		rgArgs.push("--regexp", args.pattern);
+		if (args.path) rgArgs.push("--", args.path);
+		return rgArgs;
+	}
+	/**
+	* Run ripgrep command
+	*/
+	runRipgrep(rgArgs, args) {
+		return new Promise((resolve) => {
+			let output = "";
+			let timedOut = false;
+			let truncated = false;
+			const child = spawn(this.rgPath, rgArgs, {
+				cwd: this.cwd,
+				env: process.env,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			const timeoutId = setTimeout(() => {
+				timedOut = true;
+				child.kill("SIGTERM");
+				setTimeout(() => {
+					if (!child.killed) child.kill("SIGKILL");
+				}, 5e3);
+			}, DEFAULT_TIMEOUT);
+			child.stdout?.on("data", (data) => {
+				const str = data.toString();
+				if (output.length + str.length > MAX_OUTPUT_LENGTH) {
+					output += str.slice(0, MAX_OUTPUT_LENGTH - output.length);
+					truncated = true;
+				} else output += str;
+			});
+			child.stderr?.on("data", (data) => {
+				const str = data.toString();
+				if (str.includes("error:")) output += `\n[stderr]: ${str}`;
+			});
+			child.on("close", (code) => {
+				clearTimeout(timeoutId);
+				let finalOutput = output;
+				if (args.offset || args.head_limit) {
+					const lines = output.split("\n").filter((line) => line.trim());
+					const offset = args.offset ?? 0;
+					const limit = args.head_limit ?? lines.length;
+					finalOutput = lines.slice(offset, offset + limit).join("\n");
+				}
+				let matchCount;
+				if (args.output_mode === "count") matchCount = finalOutput.split("\n").filter((line) => line.trim()).reduce((sum, line) => {
+					const match = line.match(/:(\d+)$/);
+					return sum + (match ? Number.parseInt(match[1], 10) : 0);
+				}, 0);
+				resolve({
+					exitCode: code,
+					output: truncated ? `${finalOutput}\n... [output truncated]` : finalOutput,
+					truncated,
+					timedOut,
+					matchCount
+				});
+			});
+			child.on("error", (error) => {
+				clearTimeout(timeoutId);
+				if (error?.code === "ENOENT") {
+					this.runSystemGrep(args).then(resolve);
+					return;
+				}
+				resolve({
+					exitCode: 1,
+					engine: "rg",
+					output: `Failed to execute ripgrep: ${error.message}. Make sure 'rg' is installed and in PATH.`,
+					truncated: false,
+					timedOut: false
+				});
+			});
+		});
+	}
+	runSystemGrep(args) {
+		return new Promise((resolve) => {
+			let output = "";
+			let timedOut = false;
+			let truncated = false;
+			const grepArgs = [];
+			grepArgs.push("-R", "-E", "-I");
+			const mode = args.output_mode ?? "files_with_matches";
+			if (mode === "files_with_matches") grepArgs.push("-l");
+			else if (mode === "count") grepArgs.push("-c");
+			else grepArgs.push("-n");
+			if (mode === "content") {
+				if (args["-B"] !== void 0 && args["-B"] > 0) grepArgs.push("-B", String(args["-B"]));
+				if (args["-A"] !== void 0 && args["-A"] > 0) grepArgs.push("-A", String(args["-A"]));
+				if (args["-C"] !== void 0 && args["-C"] > 0) grepArgs.push("-C", String(args["-C"]));
+			}
+			if (args["-i"]) grepArgs.push("-i");
+			grepArgs.push(args.pattern);
+			if (args.path) grepArgs.push(args.path);
+			else grepArgs.push(".");
+			const child = spawn("grep", grepArgs, {
+				cwd: this.cwd,
+				env: process.env,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			const timeoutId = setTimeout(() => {
+				timedOut = true;
+				child.kill("SIGTERM");
+				setTimeout(() => {
+					if (!child.killed) child.kill("SIGKILL");
+				}, 5e3);
+			}, DEFAULT_TIMEOUT);
+			child.stdout?.on("data", (data) => {
+				const str = data.toString();
+				if (output.length + str.length > MAX_OUTPUT_LENGTH) {
+					output += str.slice(0, MAX_OUTPUT_LENGTH - output.length);
+					truncated = true;
+				} else output += str;
+			});
+			child.stderr?.on("data", (data) => {
+				const str = data.toString();
+				if (str.trim()) output += `\n[stderr]: ${str}`;
+			});
+			child.on("close", (code) => {
+				clearTimeout(timeoutId);
+				let finalOutput = output;
+				if (args.offset || args.head_limit) {
+					const lines = output.split("\n").filter((line) => line.trim());
+					const offset = args.offset ?? 0;
+					const limit = args.head_limit ?? lines.length;
+					finalOutput = lines.slice(offset, offset + limit).join("\n");
+				}
+				let matchCount;
+				if (mode === "count") matchCount = finalOutput.split("\n").filter((line) => line.trim()).reduce((sum, line) => {
+					const last = line.split(":").pop();
+					const n = last ? Number.parseInt(last, 10) : NaN;
+					return sum + (Number.isFinite(n) ? n : 0);
+				}, 0);
+				resolve({
+					exitCode: code,
+					engine: "grep",
+					output: truncated ? `${finalOutput}\n... [output truncated]` : finalOutput,
+					truncated,
+					timedOut,
+					matchCount
+				});
+			});
+			child.on("error", (error) => {
+				clearTimeout(timeoutId);
+				resolve({
+					exitCode: 1,
+					engine: "grep",
+					output: `Failed to execute grep: ${error.message}.`,
+					truncated: false,
+					timedOut: false
+				});
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/tool/builtin/read.ts
+/**
+* Default maximum number of lines to read
+*/
+const DEFAULT_LINE_LIMIT = 2e3;
+/**
+* Maximum characters per line before truncation
+*/
+const MAX_LINE_LENGTH = 2e3;
+/**
+* Known binary/image file extensions
+*/
+const BINARY_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".bmp",
+	".ico",
+	".webp",
+	".svg",
+	".pdf",
+	".zip",
+	".tar",
+	".gz",
+	".rar",
+	".7z",
+	".exe",
+	".dll",
+	".so",
+	".dylib",
+	".mp3",
+	".mp4",
+	".avi",
+	".mov",
+	".wav",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot"
+]);
+/**
+* MIME types for common file extensions
+*/
+const MIME_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".svg": "image/svg+xml",
+	".pdf": "application/pdf",
+	".json": "application/json",
+	".js": "text/javascript",
+	".ts": "text/typescript",
+	".html": "text/html",
+	".css": "text/css",
+	".md": "text/markdown",
+	".txt": "text/plain"
+};
+/**
+* Tool for reading files from the filesystem.
+*
+* This tool reads files with line number formatting, supporting
+* offset/limit for large files and detecting binary content.
+*
+* @example
+* ```typescript
+* const readTool = new ReadTool()
+* const result = await readTool.execute({
+*   file_path: '/path/to/file.ts',
+*   offset: 100,
+*   limit: 50
+* })
+* ```
+*
+* @example Restrict reads to a specific directory
+* ```typescript
+* const readTool = new ReadTool({
+*   cwd: '/app/output',
+*   restrictToDirectory: true
+* })
+* // All paths will be resolved relative to /app/output
+* // Absolute paths and path traversal (../) will be blocked
+* ```
+*/
+var ReadTool = class extends BaseTool {
+	name = "Read";
+	/** Current working directory for resolving relative paths */
+	_cwd;
+	/** Allowed directory for file operations (if set, restricts reads to this directory) */
+	_allowedDirectory;
+	constructor(options) {
+		super();
+		this._cwd = options?.cwd ?? process.cwd();
+		this._allowedDirectory = options?.allowedDirectory;
+	}
+	/**
+	* Dynamic description that includes allowed directory info if configured
+	*/
+	get description() {
+		const baseDescription = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+
+Usage notes:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${DEFAULT_LINE_LIMIT} lines starting from the beginning
+- You can optionally specify a line offset and limit for large files
+- Any lines longer than ${MAX_LINE_LENGTH} characters will be truncated
+- Results are returned with line numbers (like cat -n format)
+- Can read images (PNG, JPG, etc.), PDFs, and Jupyter notebooks
+- You can call multiple tools in parallel to read multiple files at once`;
+		if (this._allowedDirectory) return `${baseDescription}
+- IMPORTANT: Files can ONLY be read from within: ${this._allowedDirectory}
+- Use absolute paths starting with ${this._allowedDirectory}/ (e.g., ${this._allowedDirectory}/filename.html)`;
+		return baseDescription;
+	}
+	/**
+	* Dynamic parameters that include allowed directory info if configured
+	*/
+	get parameters() {
+		return {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: this._allowedDirectory ? `The absolute path to the file to read (must be within ${this._allowedDirectory})` : "The absolute path to the file to read"
+				},
+				offset: {
+					type: "number",
+					description: "The line number to start reading from (1-based). Only provide if the file is too large to read at once."
+				},
+				limit: {
+					type: "number",
+					description: "The number of lines to read. Only provide if the file is too large to read at once."
+				}
+			},
+			required: ["file_path"]
+		};
+	}
+	/**
+	* Set the current working directory
+	*/
+	setCwd(cwd) {
+		this._cwd = cwd;
+	}
+	/**
+	* Get the current working directory
+	*/
+	getCwd() {
+		return this._cwd;
+	}
+	/**
+	* Set the allowed directory for file operations
+	*/
+	setAllowedDirectory(dir) {
+		this._allowedDirectory = dir;
+	}
+	/**
+	* Get the allowed directory for file operations
+	*/
+	getAllowedDirectory() {
+		return this._allowedDirectory;
+	}
+	/**
+	* Execute file read
+	*
+	* @param args - Read arguments
+	* @returns MCP-compliant CallToolResult with file content
+	*/
+	async execute(args) {
+		const { file_path, offset, limit } = this.validateArgs(args);
+		const filePath = path.isAbsolute(file_path) ? file_path : path.resolve(this._cwd, file_path);
+		if (this._allowedDirectory) {
+			const normalizedAllowed = path.resolve(this._allowedDirectory);
+			const normalizedFilePath = path.resolve(filePath);
+			if (!normalizedFilePath.startsWith(normalizedAllowed + path.sep) && normalizedFilePath !== normalizedAllowed) return errorContent(`Access denied: ${file_path}\nFiles can only be read from within: ${this._allowedDirectory}\nPlease use a path like: ${this._allowedDirectory}/<filename>`);
+		}
+		let stats;
+		try {
+			stats = await stat(filePath);
+		} catch (error) {
+			if (error.code === "ENOENT") return errorContent(`File not found: ${filePath}`);
+			throw error;
+		}
+		if (stats.isDirectory()) return errorContent(`Path is a directory, not a file: ${filePath}. Use ls command via Bash tool to read directories.`);
+		const ext = path.extname(filePath).toLowerCase();
+		const isBinary = BINARY_EXTENSIONS.has(ext);
+		const mimeType = MIME_TYPES[ext];
+		let result;
+		if (isBinary) {
+			result = await this.handleBinaryFile(filePath, stats.size, mimeType);
+			if (mimeType?.startsWith("image/")) return {
+				content: [{
+					type: "image",
+					data: (await readFile(filePath)).toString("base64"),
+					mimeType
+				}],
+				structuredContent: result
+			};
+		} else if (ext === ".ipynb") result = await this.handleJupyterNotebook(filePath, stats.size, offset, limit);
+		else result = await this.handleTextFile(filePath, stats.size, offset, limit);
+		return {
+			content: [{
+				type: "text",
+				text: result.content
+			}],
+			structuredContent: result
+		};
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const filePath = args.file_path;
+		if (typeof filePath !== "string" || !filePath.trim()) throw new Error("file_path is required and must be a non-empty string");
+		const result = { file_path: filePath.trim() };
+		if (args.offset !== void 0 && args.offset !== null) {
+			if (typeof args.offset !== "number") throw new TypeError("offset must be a number");
+			result.offset = Math.max(1, Math.floor(args.offset));
+		}
+		if (args.limit !== void 0 && args.limit !== null) {
+			if (typeof args.limit !== "number") throw new TypeError("limit must be a number");
+			result.limit = Math.max(1, Math.floor(args.limit));
+		}
+		return result;
+	}
+	/**
+	* Handle binary file (images, PDFs, etc.)
+	*/
+	async handleBinaryFile(filePath, fileSize, mimeType) {
+		const base64 = (await readFile(filePath)).toString("base64");
+		return {
+			content: `[Binary file: ${path.basename(filePath)}]\nSize: ${this.formatSize(fileSize)}\nMIME type: ${mimeType ?? "unknown"}\nBase64 encoded content:\n${base64}`,
+			totalLines: 1,
+			linesReturned: 1,
+			startLine: 1,
+			truncated: false,
+			fileSize,
+			isBinary: true,
+			mimeType
+		};
+	}
+	/**
+	* Handle Jupyter notebook file
+	*/
+	async handleJupyterNotebook(filePath, fileSize, offset, limit) {
+		const content = await readFile(filePath, "utf-8");
+		let notebook;
+		try {
+			notebook = JSON.parse(content);
+		} catch {
+			throw new Error(`Invalid Jupyter notebook format: ${filePath}`);
+		}
+		const cells = notebook.cells || [];
+		const outputLines = [];
+		for (let i = 0; i < cells.length; i++) {
+			const cell = cells[i];
+			const cellNum = i + 1;
+			const cellType = cell.cell_type || "unknown";
+			outputLines.push(`--- Cell ${cellNum} (${cellType}) ---`);
+			const source = Array.isArray(cell.source) ? cell.source.join("") : cell.source || "";
+			outputLines.push(...source.split("\n"));
+			if (cell.outputs && cell.outputs.length > 0) {
+				outputLines.push("--- Output ---");
+				for (const output of cell.outputs) if (output.text) {
+					const text = Array.isArray(output.text) ? output.text.join("") : output.text;
+					outputLines.push(...text.split("\n"));
+				} else if (output.data) {
+					if (output.data["text/plain"]) {
+						const text = Array.isArray(output.data["text/plain"]) ? output.data["text/plain"].join("") : output.data["text/plain"];
+						outputLines.push(...text.split("\n"));
+					}
+				}
+			}
+			outputLines.push("");
+		}
+		return this.formatOutput(outputLines, fileSize, offset, limit);
+	}
+	/**
+	* Handle text file
+	*/
+	async handleTextFile(filePath, fileSize, offset, limit) {
+		const content = await readFile(filePath, "utf-8");
+		if (content.length === 0) return {
+			content: "[File is empty]",
+			totalLines: 0,
+			linesReturned: 0,
+			startLine: 1,
+			truncated: false,
+			fileSize,
+			isBinary: false
+		};
+		const lines = content.split("\n");
+		return this.formatOutput(lines, fileSize, offset, limit);
+	}
+	/**
+	* Format output with line numbers and apply offset/limit
+	*/
+	formatOutput(lines, fileSize, offset, limit) {
+		const totalLines = lines.length;
+		const startLine = offset ?? 1;
+		const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+		const startIndex = startLine - 1;
+		const endIndex = Math.min(startIndex + lineLimit, totalLines);
+		const selectedLines = lines.slice(startIndex, endIndex);
+		let truncated = false;
+		return {
+			content: selectedLines.map((line, idx) => {
+				const lineNum = startLine + idx;
+				const lineNumStr = String(lineNum).padStart(6, " ");
+				let displayLine = line;
+				if (line.length > MAX_LINE_LENGTH) {
+					displayLine = `${line.slice(0, MAX_LINE_LENGTH)}... [truncated]`;
+					truncated = true;
+				}
+				return `${lineNumStr}|${displayLine}`;
+			}).join("\n"),
+			totalLines,
+			linesReturned: selectedLines.length,
+			startLine,
+			truncated,
+			fileSize,
+			isBinary: false
+		};
+	}
+	/**
+	* Format file size for display
+	*/
+	formatSize(bytes) {
+		const units = [
+			"B",
+			"KB",
+			"MB",
+			"GB"
+		];
+		let size = bytes;
+		let unitIndex = 0;
+		while (size >= 1024 && unitIndex < units.length - 1) {
+			size /= 1024;
+			unitIndex++;
+		}
+		return `${size.toFixed(unitIndex === 0 ? 0 : 2)} ${units[unitIndex]}`;
+	}
+};
+
+//#endregion
+//#region src/tool/builtin/edit.ts
+/**
+* Tool for performing exact string replacements in files.
+*
+* This tool finds and replaces text in files with careful handling
+* of unique matches and the option to replace all occurrences.
+*
+* @example
+* ```typescript
+* const editTool = new EditTool()
+* const result = await editTool.execute({
+*   file_path: '/path/to/file.ts',
+*   old_string: 'const foo = 1',
+*   new_string: 'const foo = 2'
+* })
+* ```
+*/
+var EditTool = class extends BaseTool {
+	name = "Edit";
+	riskLevel = "high";
+	description = `Performs exact string replacements in files.
+
+Usage notes:
+- When editing, preserve the exact indentation (tabs/spaces) from the original file
+- The edit will FAIL if old_string is not unique in the file unless replace_all is true
+- Use replace_all for replacing/renaming strings across the entire file
+- old_string and new_string must be different
+- ALWAYS prefer editing existing files over creating new ones`;
+	parameters = {
+		type: "object",
+		properties: {
+			file_path: {
+				type: "string",
+				description: "The absolute path to the file to modify"
+			},
+			old_string: {
+				type: "string",
+				description: "The text to replace"
+			},
+			new_string: {
+				type: "string",
+				description: "The text to replace it with (must be different from old_string)"
+			},
+			replace_all: {
+				type: "boolean",
+				description: "Replace all occurrences of old_string (default false)"
+			}
+		},
+		required: [
+			"file_path",
+			"old_string",
+			"new_string"
+		]
+	};
+	/** Current working directory for resolving relative paths */
+	cwd;
+	constructor(options) {
+		super();
+		this.cwd = options?.cwd ?? process.cwd();
+	}
+	/**
+	* Set the current working directory
+	*/
+	setCwd(cwd) {
+		this.cwd = cwd;
+	}
+	/**
+	* Get the current working directory
+	*/
+	getCwd() {
+		return this.cwd;
+	}
+	/**
+	* Execute file edit
+	*
+	* @param args - Edit arguments
+	* @returns MCP-compliant CallToolResult with edit details
+	*/
+	async execute(args) {
+		const { file_path, old_string, new_string, replace_all } = this.validateArgs(args);
+		const filePath = path.isAbsolute(file_path) ? file_path : path.resolve(this.cwd, file_path);
+		try {
+			if ((await stat(filePath)).isDirectory()) return errorContent(`Path is a directory, not a file: ${filePath}`);
+		} catch (error) {
+			if (error.code === "ENOENT") return errorContent(`File not found: ${filePath}`);
+			throw error;
+		}
+		const content = await readFile(filePath, "utf-8");
+		const occurrences = this.countOccurrences(content, old_string);
+		if (occurrences === 0) return errorContent(`old_string not found in file: ${filePath}\n\nSearched for:\n${this.truncateForError(old_string)}`);
+		if (occurrences > 1 && !replace_all) return errorContent(`old_string is not unique in the file (found ${occurrences} occurrences). Either provide more context to make it unique, or set replace_all: true to replace all occurrences.`);
+		let newContent;
+		let replacements;
+		if (replace_all) {
+			newContent = content.split(old_string).join(new_string);
+			replacements = occurrences;
+		} else {
+			const index = content.indexOf(old_string);
+			newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+			replacements = 1;
+		}
+		await writeFile(filePath, newContent, "utf-8");
+		const result = {
+			success: true,
+			replacements,
+			filePath,
+			message: `Successfully replaced ${replacements} occurrence${replacements > 1 ? "s" : ""} in ${path.basename(filePath)}`
+		};
+		return {
+			content: [{
+				type: "text",
+				text: result.message
+			}],
+			structuredContent: result
+		};
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const filePath = args.file_path;
+		const oldString = args.old_string;
+		const newString = args.new_string;
+		if (typeof filePath !== "string" || !filePath.trim()) throw new Error("file_path is required and must be a non-empty string");
+		if (typeof oldString !== "string") throw new TypeError("old_string is required and must be a string");
+		if (oldString === "") throw new Error("old_string cannot be empty");
+		if (typeof newString !== "string") throw new TypeError("new_string is required and must be a string");
+		if (oldString === newString) throw new Error("new_string must be different from old_string");
+		return {
+			file_path: filePath.trim(),
+			old_string: oldString,
+			new_string: newString,
+			replace_all: args.replace_all === true
+		};
+	}
+	/**
+	* Count occurrences of a substring in a string
+	*/
+	countOccurrences(str, substr) {
+		let count = 0;
+		let pos = str.indexOf(substr);
+		while (pos !== -1) {
+			count++;
+			pos = str.indexOf(substr, pos + substr.length);
+		}
+		return count;
+	}
+	/**
+	* Truncate string for error messages
+	*/
+	truncateForError(str, maxLength = 200) {
+		if (str.length <= maxLength) return str;
+		return `${str.slice(0, maxLength)}... [truncated, ${str.length} chars total]`;
+	}
+};
+
+//#endregion
+//#region src/tool/builtin/write.ts
+/**
+* Tool for writing files to the filesystem.
+*
+* This tool creates or overwrites files with the specified content,
+* automatically creating parent directories if needed.
+*
+* @example
+* ```typescript
+* const writeTool = new WriteTool()
+* const result = await writeTool.execute({
+*   file_path: '/path/to/file.ts',
+*   content: 'export const foo = 1'
+* })
+* ```
+*
+* @example Restrict writes to a specific directory
+* ```typescript
+* const writeTool = new WriteTool({
+*   cwd: '/app/output',
+*   restrictToDirectory: true
+* })
+* // All paths will be resolved relative to /app/output
+* // Absolute paths and path traversal (../) will be blocked
+* ```
+*/
+var WriteTool = class extends BaseTool {
+	name = "Write";
+	riskLevel = "high";
+	/** Current working directory for resolving relative paths */
+	_cwd;
+	/** Allowed directory for file operations (if set, restricts writes to this directory) */
+	_allowedDirectory;
+	constructor(options) {
+		super();
+		this._cwd = options?.cwd ?? process.cwd();
+		this._allowedDirectory = options?.allowedDirectory;
+	}
+	/**
+	* Dynamic description that includes allowed directory info if configured
+	*/
+	get description() {
+		const baseDescription = `Writes a file to the local filesystem.
+
+Usage notes:
+- This tool will overwrite the existing file if there is one at the provided path
+- Parent directories will be created automatically if they don't exist
+- ALWAYS prefer editing existing files over writing new ones
+- NEVER proactively create documentation files (*.md) or README files unless explicitly requested`;
+		if (this._allowedDirectory) return `${baseDescription}
+- IMPORTANT: Files can ONLY be written within: ${this._allowedDirectory}
+- Use absolute paths starting with ${this._allowedDirectory}/ (e.g., ${this._allowedDirectory}/filename.html)`;
+		return baseDescription;
+	}
+	/**
+	* Dynamic parameters that include allowed directory info if configured
+	*/
+	get parameters() {
+		return {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: this._allowedDirectory ? `The absolute path to the file to write (must be within ${this._allowedDirectory})` : "The absolute path to the file to write (must be absolute, not relative)"
+				},
+				content: {
+					type: "string",
+					description: "The content to write to the file"
+				}
+			},
+			required: ["file_path", "content"]
+		};
+	}
+	/**
+	* Set the current working directory
+	*/
+	setCwd(cwd) {
+		this._cwd = cwd;
+	}
+	/**
+	* Get the current working directory
+	*/
+	getCwd() {
+		return this._cwd;
+	}
+	/**
+	* Set the allowed directory for file operations
+	*/
+	setAllowedDirectory(dir) {
+		this._allowedDirectory = dir;
+	}
+	/**
+	* Get the allowed directory for file operations
+	*/
+	getAllowedDirectory() {
+		return this._allowedDirectory;
+	}
+	/**
+	* Execute file write
+	*
+	* @param args - Write arguments
+	* @returns MCP-compliant CallToolResult with write details
+	*/
+	async execute(args) {
+		const { file_path, content } = this.validateArgs(args);
+		const filePath = path.isAbsolute(file_path) ? file_path : path.resolve(this._cwd, file_path);
+		if (this._allowedDirectory) {
+			const normalizedAllowed = path.resolve(this._allowedDirectory);
+			const normalizedFilePath = path.resolve(filePath);
+			if (!normalizedFilePath.startsWith(normalizedAllowed + path.sep) && normalizedFilePath !== normalizedAllowed) return errorContent(`Access denied: ${file_path}\nFiles can only be written within: ${this._allowedDirectory}\nPlease use a path like: ${this._allowedDirectory}/<filename>`);
+		}
+		let overwritten = false;
+		try {
+			if ((await stat(filePath)).isDirectory()) return errorContent(`Path is a directory, not a file: ${filePath}`);
+			overwritten = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await mkdir(path.dirname(filePath), { recursive: true });
+		await writeFile(filePath, content, "utf-8");
+		const bytesWritten = Buffer.byteLength(content, "utf-8");
+		const result = {
+			success: true,
+			filePath,
+			bytesWritten,
+			overwritten,
+			message: overwritten ? `Successfully overwrote ${path.basename(filePath)} (${this.formatSize(bytesWritten)})` : `Successfully created ${path.basename(filePath)} (${this.formatSize(bytesWritten)})`
+		};
+		return {
+			content: [{
+				type: "text",
+				text: result.message
+			}],
+			structuredContent: result
+		};
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const filePath = args.file_path;
+		const content = args.content;
+		if (typeof filePath !== "string" || !filePath.trim()) throw new Error("file_path is required and must be a non-empty string");
+		if (typeof content !== "string") throw new TypeError("content is required and must be a string");
+		return {
+			file_path: filePath.trim(),
+			content
+		};
+	}
+	/**
+	* Format file size for display
+	*/
+	formatSize(bytes) {
+		const units = [
+			"B",
+			"KB",
+			"MB",
+			"GB"
+		];
+		let size = bytes;
+		let unitIndex = 0;
+		while (size >= 1024 && unitIndex < units.length - 1) {
+			size /= 1024;
+			unitIndex++;
+		}
+		return `${size.toFixed(unitIndex === 0 ? 0 : 2)} ${units[unitIndex]}`;
+	}
+};
+
+//#endregion
+//#region src/tool/builtin/webSearch.ts
+/**
+* Tool for searching the web using Serper API.
+*
+* This tool allows the agent to search the web and use the results
+* to inform responses with up-to-date information.
+*
+* @example
+* ```typescript
+* const webSearchTool = new WebSearchTool({ apiKey: 'your-serper-api-key' })
+* const result = await webSearchTool.execute({
+*   query: 'latest TypeScript features 2025'
+* })
+* ```
+*/
+var WebSearchTool = class extends BaseTool {
+	name = "WebSearch";
+	description = `Allows the agent to search the web and use the results to inform responses.
+
+Usage notes:
+- Provides up-to-date information for current events and recent data
+- Returns search results with titles, links, and snippets
+- Use this tool for accessing information beyond the knowledge cutoff
+- After answering, include a "Sources:" section with relevant URLs as markdown hyperlinks`;
+	parameters = {
+		type: "object",
+		properties: { query: {
+			type: "string",
+			minLength: 2,
+			description: "The search query to use"
+		} },
+		required: ["query"]
+	};
+	/** Serper API key */
+	apiKey;
+	/** Serper API endpoint */
+	apiEndpoint;
+	/** Number of results to return */
+	numResults;
+	constructor(options) {
+		super();
+		this.apiKey = options?.apiKey ?? process.env.SERPER_API_KEY ?? "";
+		this.apiEndpoint = options?.apiEndpoint ?? "https://google.serper.dev/search?format=json";
+		this.numResults = options?.numResults ?? 10;
+	}
+	/**
+	* Set API key
+	*/
+	setApiKey(apiKey) {
+		this.apiKey = apiKey;
+	}
+	/**
+	* Execute web search
+	*
+	* @param args - WebSearch arguments
+	* @returns MCP-compliant CallToolResult with search results
+	*/
+	async execute(args) {
+		const { query } = this.validateArgs(args);
+		if (!this.apiKey) return errorContent("Serper API key is not configured. Set SERPER_API_KEY environment variable or pass apiKey in constructor.");
+		try {
+			const response = await fetch(this.apiEndpoint, {
+				method: "POST",
+				headers: {
+					"X-API-KEY": this.apiKey,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					q: query,
+					num: this.numResults
+				})
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				return errorContent(`Serper API error (${response.status}): ${errorText}`);
+			}
+			const results = ((await response.json()).organic ?? []).map((item, index) => ({
+				title: item.title,
+				link: item.link,
+				snippet: item.snippet,
+				position: item.position ?? index + 1
+			}));
+			const markdown = this.formatMarkdown(query, results);
+			const result = {
+				success: true,
+				query,
+				results,
+				totalResults: results.length,
+				markdown
+			};
+			return {
+				content: [{
+					type: "text",
+					text: markdown
+				}],
+				structuredContent: result
+			};
+		} catch (error) {
+			return errorContent(`Failed to execute search: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Validate and parse arguments
+	*/
+	validateArgs(args) {
+		const query = args.query;
+		if (typeof query !== "string" || query.trim().length < 2) throw new Error("query is required and must be at least 2 characters");
+		return { query: query.trim() };
+	}
+	/**
+	* Format search results as markdown
+	*/
+	formatMarkdown(query, results) {
+		if (results.length === 0) return `No results found for: "${query}"`;
+		const lines = [`## Search Results for: "${query}"`, ""];
+		for (const result of results) {
+			lines.push(`### ${result.position}. [${result.title}](${result.link})`);
+			lines.push("");
+			lines.push(result.snippet);
+			lines.push("");
+		}
+		lines.push("---");
+		lines.push("");
+		lines.push("**Sources:**");
+		for (const result of results) lines.push(`- [${result.title}](${result.link})`);
+		return lines.join("\n");
+	}
+};
+
+//#endregion
+//#region src/tool/registry.ts
+/**
+* Registry for managing tools.
+*
+* Provides methods to register, unregister, and look up tools,
+* as well as convert to OpenAI-compatible format.
+*/
+var ToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	/**
+	* Register a tool
+	*
+	* @param tool - Tool to register
+	* @throws Error if tool with same name already exists
+	*/
+	register(tool) {
+		if (this.tools.has(tool.name)) throw new Error(`Tool "${tool.name}" already registered`);
+		this.tools.set(tool.name, tool);
+	}
+	/**
+	* Unregister a tool by name
+	*
+	* @param name - Name of tool to remove
+	* @returns true if tool was found and removed
+	*/
+	unregister(name) {
+		return this.tools.delete(name);
+	}
+	/**
+	* Get a tool by name
+	*
+	* @param name - Tool name
+	* @returns Tool instance or undefined if not found
+	*/
+	get(name) {
+		return this.tools.get(name);
+	}
+	/**
+	* List all registered tools
+	*
+	* @returns Array of all tools
+	*/
+	list() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* Check if a tool is registered
+	*
+	* @param name - Tool name
+	* @returns true if tool exists
+	*/
+	has(name) {
+		return this.tools.has(name);
+	}
+	/**
+	* Get count of registered tools
+	*/
+	get size() {
+		return this.tools.size;
+	}
+	/**
+	* Convert all tools to OpenAI-compatible format
+	*
+	* @returns Array of tools in OpenAI function calling format
+	*/
+	toOpenAIFormat() {
+		return this.list().map((tool) => ({
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.parameters
+			}
+		}));
+	}
+};
+
+//#endregion
+export { Agent, AgentAbortError, AgentMaxIterationsError, BaseModel, BaseSession, BaseSessionManager, BaseTool, EditTool, FileStateStore as FileCheckpointStore, FileStateStore, GlobTool, GrepTool, InMemoryStateStore as InMemoryCheckpointStore, InMemoryStateStore, InMemoryModelHealth, ModelError, ReadTool, RetryPolicy, StateKeys, StateStore, ToolRegistry, WebSearchTool, WriteTool, compose, compressSessionManually, createContextCompressionMiddleware, createInitialLoopState, createInitialLoopStateFromMessages, createModel, createOpenAIAdapter, ensureNotAborted, errorContent, fromLoopCheckpoint, imageContent, textContent, toLoopCheckpoint };