lemura 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var crypto = require('crypto');
+var child_process = require('child_process');
 
 // src/types/errors.ts
 var LemuraError = class extends Error {
@@ -62,6 +63,24 @@ var LemuraToolTimeoutError = class extends LemuraError {
     this.name = "LemuraToolTimeoutError";
   }
 };
+var LemuraMCPError = class extends LemuraError {
+  constructor(message, code = "MCP_ERROR", problem, hints = []) {
+    super(message, code, problem, hints);
+    this.name = "LemuraMCPError";
+  }
+};
+var LemuraMCPConnectionError = class extends LemuraMCPError {
+  constructor(message, problem, hints = []) {
+    super(message, "MCP_CONNECTION_FAILED", problem, hints);
+    this.name = "LemuraMCPConnectionError";
+  }
+};
+var LemuraMCPTimeoutError = class extends LemuraMCPError {
+  constructor(message) {
+    super(message, "MCP_TOOL_TIMEOUT");
+    this.name = "LemuraMCPTimeoutError";
+  }
+};
 
 // src/types/logger.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -76,7 +95,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
 // src/adapters/OpenAICompatibleAdapter.ts
 var OpenAICompatibleAdapter = class {
   name = "openai_compatible";
-  version = "1.0.0";
+  version = "1.2.0";
   baseUrl;
   apiKey;
   defaultModel;
@@ -325,7 +344,7 @@ var OpenAICompatibleAdapter = class {
     const blob = new Blob([bytes], { type: request.mimeType });
     const formData = new FormData();
     formData.append("file", blob, "audio.webm");
-    formData.append("model", "whisper-1");
+    formData.append("model", request.model || "whisper-1");
     if (request.language) formData.append("language", request.language);
     const response = await this.fetchWithRetry(`${this.baseUrl}/audio/transcriptions`, {
       method: "POST",
@@ -346,7 +365,7 @@ var OpenAICompatibleAdapter = class {
     const response = await this.fetchWithRetry(`${this.baseUrl}/audio/speech`, {
       method: "POST",
       body: JSON.stringify({
-        model: "tts-1",
+        model: request.model || "tts-1",
         input: request.text,
         voice: request.voiceId || "alloy",
         response_format: request.format || "mp3"
@@ -369,7 +388,7 @@ var OpenAICompatibleAdapter = class {
   }
   async describeImage(request) {
     const payload = {
-      model: this.defaultModel,
+      model: request.model || this.defaultModel,
       messages: [
         {
           role: "user",
@@ -401,7 +420,7 @@ var OpenAICompatibleAdapter = class {
       method: "POST",
       body: JSON.stringify({
         prompt: request.prompt,
-        model: "dall-e-3",
+        model: request.model || "dall-e-3",
         n: 1,
         size: request.dimensions || "1024x1024"
       })
@@ -699,40 +718,336 @@ var InMemoryStorageAdapter = class {
   }
 };
 
+// src/tools/SchemaValidator.ts
+function typeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function matchesType(value, requiredType) {
+  const t = typeOf(value);
+  if (requiredType === "integer") return t === "number" && Number.isInteger(value);
+  return t === requiredType;
+}
+function validateJsonSchema(value, schema, path = "") {
+  const errors = [];
+  if (schema["type"] !== void 0) {
+    const expectedType = schema["type"];
+    const types = Array.isArray(expectedType) ? expectedType : [expectedType];
+    if (!types.some((t) => matchesType(value, t))) {
+      errors.push({
+        path,
+        message: `Expected type '${types.join("|")}', got '${typeOf(value)}'`
+      });
+      return errors;
+    }
+  }
+  if (schema["enum"] !== void 0) {
+    const allowed = schema["enum"];
+    if (!allowed.some((a) => JSON.stringify(a) === JSON.stringify(value))) {
+      errors.push({ path, message: `Value must be one of: ${JSON.stringify(allowed)}` });
+    }
+  }
+  if ("const" in schema) {
+    if (JSON.stringify(schema["const"]) !== JSON.stringify(value)) {
+      errors.push({ path, message: `Value must equal ${JSON.stringify(schema["const"])}` });
+    }
+  }
+  if (typeof value === "string") {
+    if (schema["minLength"] !== void 0 && value.length < schema["minLength"]) {
+      errors.push({ path, message: `String too short (min ${schema["minLength"]}, got ${value.length})` });
+    }
+    if (schema["maxLength"] !== void 0 && value.length > schema["maxLength"]) {
+      errors.push({ path, message: `String too long (max ${schema["maxLength"]}, got ${value.length})` });
+    }
+    if (schema["pattern"] !== void 0) {
+      try {
+        const re = new RegExp(schema["pattern"]);
+        if (!re.test(value)) {
+          errors.push({ path, message: `String does not match pattern /${schema["pattern"]}/` });
+        }
+      } catch {
+      }
+    }
+  }
+  if (typeof value === "number") {
+    if (schema["minimum"] !== void 0 && value < schema["minimum"]) {
+      errors.push({ path, message: `Value ${value} is less than minimum ${schema["minimum"]}` });
+    }
+    if (schema["maximum"] !== void 0 && value > schema["maximum"]) {
+      errors.push({ path, message: `Value ${value} exceeds maximum ${schema["maximum"]}` });
+    }
+    if (schema["exclusiveMinimum"] !== void 0 && value <= schema["exclusiveMinimum"]) {
+      errors.push({ path, message: `Value ${value} must be > ${schema["exclusiveMinimum"]}` });
+    }
+    if (schema["exclusiveMaximum"] !== void 0 && value >= schema["exclusiveMaximum"]) {
+      errors.push({ path, message: `Value ${value} must be < ${schema["exclusiveMaximum"]}` });
+    }
+  }
+  if (Array.isArray(value)) {
+    if (schema["minItems"] !== void 0 && value.length < schema["minItems"]) {
+      errors.push({ path, message: `Array too short (min ${schema["minItems"]} items)` });
+    }
+    if (schema["maxItems"] !== void 0 && value.length > schema["maxItems"]) {
+      errors.push({ path, message: `Array too long (max ${schema["maxItems"]} items)` });
+    }
+    if (schema["items"] !== void 0) {
+      const itemSchema = schema["items"];
+      value.forEach((item, idx) => {
+        const childErrors = validateJsonSchema(item, itemSchema, `${path}[${idx}]`);
+        errors.push(...childErrors);
+      });
+    }
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const props = schema["properties"] || {};
+    const required = schema["required"] || [];
+    for (const key of required) {
+      if (!(key in obj)) {
+        errors.push({ path: path ? `${path}.${key}` : key, message: `Required property '${key}' is missing` });
+      }
+    }
+    for (const [key, propSchema] of Object.entries(props)) {
+      if (key in obj) {
+        const childErrors = validateJsonSchema(obj[key], propSchema, path ? `${path}.${key}` : key);
+        errors.push(...childErrors);
+      }
+    }
+    if (schema["additionalProperties"] === false) {
+      for (const key of Object.keys(obj)) {
+        if (!(key in props)) {
+          errors.push({ path: path ? `${path}.${key}` : key, message: `Additional property '${key}' is not allowed` });
+        }
+      }
+    } else if (schema["additionalProperties"] !== void 0 && typeof schema["additionalProperties"] === "object") {
+      const addlSchema = schema["additionalProperties"];
+      for (const [key, val] of Object.entries(obj)) {
+        if (!(key in props)) {
+          const childErrors = validateJsonSchema(val, addlSchema, path ? `${path}.${key}` : key);
+          errors.push(...childErrors);
+        }
+      }
+    }
+    if (schema["minProperties"] !== void 0 && Object.keys(obj).length < schema["minProperties"]) {
+      errors.push({ path, message: `Object has fewer than ${schema["minProperties"]} properties` });
+    }
+    if (schema["maxProperties"] !== void 0 && Object.keys(obj).length > schema["maxProperties"]) {
+      errors.push({ path, message: `Object has more than ${schema["maxProperties"]} properties` });
+    }
+  }
+  if (schema["allOf"] !== void 0) {
+    for (const subSchema of schema["allOf"]) {
+      errors.push(...validateJsonSchema(value, subSchema, path));
+    }
+  }
+  if (schema["anyOf"] !== void 0) {
+    const subSchemas = schema["anyOf"];
+    const anyPassed = subSchemas.some((s) => validateJsonSchema(value, s, path).length === 0);
+    if (!anyPassed) {
+      errors.push({ path, message: "Value does not match any of the anyOf schemas" });
+    }
+  }
+  if (schema["oneOf"] !== void 0) {
+    const subSchemas = schema["oneOf"];
+    const passing = subSchemas.filter((s) => validateJsonSchema(value, s, path).length === 0);
+    if (passing.length !== 1) {
+      errors.push({
+        path,
+        message: `Value must match exactly one of the oneOf schemas (matched ${passing.length})`
+      });
+    }
+  }
+  if (schema["not"] !== void 0) {
+    const subErrors = validateJsonSchema(value, schema["not"], path);
+    if (subErrors.length === 0) {
+      errors.push({ path, message: "Value must NOT match the not schema" });
+    }
+  }
+  return errors;
+}
+
 // src/tools/ToolRegistry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
-  constructor(initialTools = []) {
+  defaultTimeoutMs;
+  constructor(initialTools = [], options = {}) {
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
     for (const tool of initialTools) {
       this.register(tool);
     }
   }
+  /**
+   * Registers a tool. Throws if a tool with the same name is already registered.
+   *
+   * @param tool - The tool definition to register
+   * @throws {LemuraError} If `tool.name` is already taken
+   */
   register(tool) {
     if (this.tools.has(tool.name)) {
-      throw new Error(`Tool ${tool.name} is already registered.`);
+      throw new LemuraToolNotFoundError(`Tool '${tool.name}' is already registered. Use a unique name.`);
     }
     this.tools.set(tool.name, tool);
   }
+  /**
+   * Removes a registered tool by name.
+   *
+   * @param name - The tool name to unregister
+   */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Returns the tool definition for `name`, or `undefined` if not found.
+   *
+   * @param name - Tool name to look up
+   */
   get(name) {
     return this.tools.get(name);
   }
+  /**
+   * Returns all registered tool definitions.
+   */
   getAll() {
     return Array.from(this.tools.values());
   }
+  /**
+   * Executes a single tool call with schema validation and timeout enforcement.
+   *
+   * @param name - The tool name to execute
+   * @param params - The raw parameter object (validated against the tool's JSON Schema)
+   * @param context - Execution context (session, logger, adapters)
+   * @returns The tool's result
+   * @throws {LemuraToolNotFoundError} If the tool is not registered
+   * @throws {LemuraToolValidationError} If params fail JSON Schema validation
+   * @throws {LemuraToolTimeoutError} If execution exceeds the configured timeout
+   */
   async execute(name, params, context) {
     const tool = this.tools.get(name);
     if (!tool) {
-      throw new LemuraToolNotFoundError(`Tool '${name}' not found.`);
+      throw new LemuraToolNotFoundError(`Tool '${name}' not found in registry.`);
+    }
+    if (tool.parameters && typeof tool.parameters === "object") {
+      const schemaErrors = validateJsonSchema(params, tool.parameters);
+      if (schemaErrors.length > 0) {
+        const msg = schemaErrors.map((e) => e.path ? `[${e.path}] ${e.message}` : e.message).join("; ");
+        throw new LemuraToolValidationError(
+          `Tool '${name}' parameter validation failed: ${msg}`
+        );
+      }
     }
+    const toolTimeoutMs = tool["timeoutMs"];
+    const timeoutMs = typeof toolTimeoutMs === "number" ? toolTimeoutMs : this.defaultTimeoutMs;
+    const executionPromise = tool.execute(params, context);
+    const timeoutPromise = new Promise((_, reject) => {
+      const id = setTimeout(() => {
+        clearTimeout(id);
+        reject(new LemuraToolTimeoutError(
+          `Tool '${name}' timed out after ${timeoutMs}ms`
+        ));
+      }, timeoutMs);
+    });
     try {
-      const result = await tool.execute(params, context);
-      return result;
+      return await Promise.race([executionPromise, timeoutPromise]);
     } catch (err) {
-      if (err instanceof LemuraToolValidationError) {
+      if (err instanceof LemuraToolValidationError || err instanceof LemuraToolTimeoutError) {
         throw err;
       }
-      throw new Error(`Tool execution failed for '${name}': ${err.message}`);
+      const message = err instanceof Error ? err.message : String(err);
+      throw new LemuraToolValidationError(
+        `Tool '${name}' execution failed: ${message}`
+      );
+    }
+  }
+  /**
+   * Executes multiple tool calls in parallel.
+   * All calls are issued simultaneously; results are returned in the same order as `calls`.
+   * Individual errors are captured per-call without aborting the others.
+   *
+   * @param calls - Array of `{ name, params }` objects
+   * @param context - Shared execution context
+   * @returns Array of `{ toolCallId, result?, error? }` in input order
+   *
+   * @example
+   * const results = await registry.executeParallel(
+   *   [{ name: 'search_web', params: { query: 'foo' } }],
+   *   context
+   * );
+   */
+  async executeParallel(calls, context) {
+    return Promise.all(
+      calls.map(async (call) => {
+        try {
+          const result = await this.execute(call.name, call.params, context);
+          return { id: call.id, result };
+        } catch (err) {
+          return { id: call.id, error: err instanceof Error ? err : new Error(String(err)) };
+        }
+      })
+    );
+  }
+};
+
+// src/tools/ToolFirewall.ts
+function matchesRule(pattern, value, logger) {
+  if (!pattern) return true;
+  try {
+    const re = new RegExp(pattern);
+    return re.test(value);
+  } catch (err) {
+    if (logger) logger.warn(`Invalid firewall regex: ${pattern}`, { error: err?.message });
+    return false;
+  }
+}
+function evaluateToolFirewall(config, toolName, argsJson, logger) {
+  const defaultDecision = config?.defaultDecision || "ask";
+  const rules = config?.rules || [];
+  for (const rule of rules) {
+    const nameOk = matchesRule(rule.name, toolName, logger);
+    const argsOk = matchesRule(rule.arguments, argsJson, logger);
+    if (nameOk && argsOk) {
+      return {
+        decision: rule.decision,
+        reason: rule.reason || "Matched firewall rule"
+      };
+    }
+  }
+  return {
+    decision: defaultDecision,
+    reason: "Default firewall decision"
+  };
+}
+
+// src/media/MediaBridge.ts
+var MediaBridge = class {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  transcribe(request) {
+    return this.adapter.transcribe(request);
+  }
+  synthesize(request) {
+    return this.adapter.synthesize(request);
+  }
+  async synthesizeToArray(request) {
+    const chunks = [];
+    for await (const chunk of this.adapter.synthesize(request)) {
+      chunks.push(chunk);
     }
+    return chunks;
+  }
+  describeImage(request) {
+    return this.adapter.describeImage(request);
+  }
+  generateImage(request) {
+    return this.adapter.generateImage(request);
+  }
+  getModelInfo() {
+    return this.adapter.getModelInfo();
+  }
+  supportsVision() {
+    return this.adapter.getModelInfo().supportsVision;
   }
 };
 
@@ -1031,146 +1346,1120 @@ var summarizeSandwichTool = {
   }
 };
 
-// src/agent/SessionManager.ts
-var SessionManager = class {
-  contextManager;
-  toolRegistry;
-  skillInjector;
-  context;
-  adapter;
-  config;
-  iterations = 0;
-  logger;
-  constructor(config) {
-    this.config = config;
-    this.adapter = config.adapter;
-    this.logger = config.logger || new DefaultLogger();
-    this.contextManager = new ContextManager();
-    this.toolRegistry = new ToolRegistry(config.tools || []);
-    this.skillInjector = new SkillInjector(config.skills || []);
-    for (const strategy of config.compressionStrategies || []) {
-      this.contextManager.registerStrategy(strategy);
+// src/tools/builtin/media.ts
+var defaultPrefix = "media_";
+function requireAdapter(context) {
+  if (!context.adapter) {
+    throw new LemuraAdapterError("Provider adapter is missing from tool context", "ADAPTER_MISSING");
+  }
+  return context.adapter;
+}
+function createMediaTools(prefix = defaultPrefix) {
+  const p = prefix || defaultPrefix;
+  const transcribeTool = {
+    name: `${p}transcribe`,
+    description: "Transcribe audio from base64 into text.",
+    parameters: {
+      type: "object",
+      properties: {
+        audioBase64: { type: "string", description: "Base64-encoded audio payload." },
+        mimeType: { type: "string", description: "Audio MIME type like audio/wav or audio/mpeg." },
+        language: { type: "string", description: "Optional language hint like en, fr." },
+        model: { type: "string", description: "Optional model override for ASR." }
+      },
+      required: ["audioBase64", "mimeType"]
+    },
+    async execute(params, context) {
+      const adapter = requireAdapter(context);
+      const result = await adapter.transcribe({
+        audioBase64: params.audioBase64,
+        mimeType: params.mimeType,
+        language: params.language,
+        model: params.model
+      });
+      return result;
     }
-    if (config.stmRegistry) {
-      this.toolRegistry.register(readChunkTool);
-      this.toolRegistry.register(searchChunkTool);
-      this.toolRegistry.register(listChunksTool);
-      this.toolRegistry.register(updateChunkTool);
-      this.toolRegistry.register(readScratchpadTool);
-      this.toolRegistry.register(writeScratchpadTool);
-      this.toolRegistry.register(removeScratchpadTool);
-      this.toolRegistry.register(summarizeSandwichTool);
+  };
+  const synthesizeTool = {
+    name: `${p}synthesize`,
+    description: "Synthesize text to speech and return audio chunks (base64).",
+    parameters: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to synthesize." },
+        voiceId: { type: "string", description: "Voice identifier." },
+        format: { type: "string", enum: ["mp3", "wav", "pcm"] },
+        model: { type: "string", description: "Optional model override for TTS." }
+      },
+      required: ["text", "voiceId", "format"]
+    },
+    async execute(params, context) {
+      const adapter = requireAdapter(context);
+      const chunks = [];
+      for await (const chunk of adapter.synthesize({
+        text: params.text,
+        voiceId: params.voiceId,
+        format: params.format,
+        model: params.model
+      })) {
+        chunks.push(chunk);
+      }
+      return { chunks };
     }
-    this.context = {
-      systemPrompt: config.systemPrompt || "",
-      scratchpad: "",
-      turns: [],
-      tokenCount: 0,
-      maxTokens: config.maxTokens,
-      metadata: {}
+  };
+  const visionTool = {
+    name: `${p}describe_image`,
+    description: "Describe an image from base64 and optional prompt.",
+    parameters: {
+      type: "object",
+      properties: {
+        imageBase64: { type: "string", description: "Base64-encoded image payload." },
+        prompt: { type: "string", description: "Optional instruction or focus for description." },
+        model: { type: "string", description: "Optional model override for vision." }
+      },
+      required: ["imageBase64"]
+    },
+    async execute(params, context) {
+      const adapter = requireAdapter(context);
+      const result = await adapter.describeImage({
+        imageBase64: params.imageBase64,
+        prompt: params.prompt,
+        model: params.model
+      });
+      return result;
+    }
+  };
+  const imageGenTool = {
+    name: `${p}generate_image`,
+    description: "Generate an image from a prompt.",
+    parameters: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Text prompt for the image." },
+        dimensions: { type: "string", description: "Image size like 1024x1024." },
+        model: { type: "string", description: "Optional model override for image generation." }
+      },
+      required: ["prompt", "dimensions"]
+    },
+    async execute(params, context) {
+      const adapter = requireAdapter(context);
+      const result = await adapter.generateImage({
+        prompt: params.prompt,
+        dimensions: params.dimensions,
+        model: params.model
+      });
+      return result;
+    }
+  };
+  return [transcribeTool, synthesizeTool, visionTool, imageGenTool];
+}
+
+// src/agent/execution/StepCounter.ts
+var StepCounter = class {
+  constructor(maxSteps = 20) {
+    this.maxSteps = maxSteps;
+  }
+  toolCallCount = 0;
+  increment(count = 1) {
+    this.toolCallCount += count;
+  }
+  get count() {
+    return this.toolCallCount;
+  }
+  isMaxReached() {
+    return this.toolCallCount >= this.maxSteps;
+  }
+  getForcedConclusionPrompt() {
+    return `You have used ${this.toolCallCount}/${this.maxSteps} steps. Provide your final response now.
+Do not call any more tools. Use the required structure below.`;
+  }
+};
+
+// src/agent/execution/FinalResponseFormatter.ts
+var FinalResponseFormatter = class {
+  static getRequiredStructure() {
+    return `## Goal Status: [ACHIEVED | PARTIALLY_ACHIEVED | FAILED]
+
+### What was accomplished
+[Summary of completed work]
+
+### Remaining tasks
+[Bulleted list, or "None"]
+
+### Failed steps
+[Tool/step name + error context, or "None"]
+
+### Result
+[The actual answer or deliverable]`;
+  }
+  static validateStructure(response) {
+    if (!response.includes("## Goal Status:")) return false;
+    if (!response.includes("### What was accomplished")) return false;
+    if (!response.includes("### Remaining tasks")) return false;
+    if (!response.includes("### Failed steps")) return false;
+    if (!response.includes("### Result")) return false;
+    return true;
+  }
+};
+
+// src/agent/execution/ToolResponseProcessor.ts
+var ToolResponseProcessor = class {
+  evaluate(response, tool, context) {
+    const length = response.length;
+    const estimatedTokens = length / 4;
+    let sizeClass = "small";
+    if (estimatedTokens > 2e3) sizeClass = "oversized";
+    else if (estimatedTokens > 800) sizeClass = "large";
+    else if (estimatedTokens > 200) sizeClass = "medium";
+    return {
+      relevanceScore: 1,
+      sizeClass,
+      shouldCompress: sizeClass === "large" || sizeClass === "oversized",
+      suggestedMaxTokens: 500,
+      answered: true,
+      answeredPartially: false,
+      errorDetected: response.toLowerCase().includes("error"),
+      suggestedAction: "continue"
     };
   }
-  getContext() {
-    return { ...this.context };
+  compress(response, evaluation) {
+    if (!evaluation.shouldCompress || evaluation.errorDetected) {
+      return response;
+    }
+    if (response.length > 1e3) {
+      return response.substring(0, 1e3) + "\n...[COMPRESSED TO SAVE TOKENS]...";
+    }
+    return response;
   }
-  getHistory() {
-    return [...this.context.turns];
+};
+
+// src/agent/execution/GoalInjector.ts
+var GoalInjector = class {
+  constructor(goal) {
+    this.goal = goal;
   }
-  async run(userMessage) {
-    this.logger.info(`Starting new session run`, {
-      model: this.config.model,
-      message: Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage
-    });
-    this.context.turns.push({
-      role: "user",
-      content: userMessage,
-      tokenCount: Array.isArray(userMessage) ? userMessage.length * 50 : this.adapter.estimateTokens(userMessage),
-      turnIndex: this.context.turns.length,
-      compressed: false
-    });
-    const maxIts = this.config.maxIterations || 10;
-    this.iterations = 0;
-    while (this.iterations < maxIts) {
-      this.iterations++;
-      this.logger.debug(`ReAct Iteration ${this.iterations}/${maxIts}`);
-      this.context = await this.contextManager.prepare(this.context);
-      const messages = this.context.turns.map((t) => ({
-        role: t.role,
-        content: t.content,
-        ...t.role === "tool" && t.toolResults?.[0] ? { name: t.toolResults[0].toolCallId } : {},
-        ...t.role === "assistant" && t.toolCalls ? { toolCalls: t.toolCalls } : {}
-      }));
-      let fullSystemPrompt = this.context.systemPrompt || "";
-      const injectedSkills = this.skillInjector.buildInjectionBlock("system_prompt");
-      if (injectedSkills) {
-        fullSystemPrompt += "\n\n" + injectedSkills;
-      }
-      if (fullSystemPrompt.trim()) {
-        messages.unshift({ role: "system", content: fullSystemPrompt.trim() });
+  injectInto(prompt) {
+    const formatting = `[CURRENT GOAL]
+${this.goal.statement}
+
+Success criteria:
+${this.goal.successCriteria.map((c) => `- ${c}`).join("\n")}
+[/CURRENT GOAL]`;
+    if (this.goal.injectionPosition === "system_prompt") {
+      return `${prompt}
+
+${formatting}`;
+    }
+    return prompt;
+  }
+  getGoal() {
+    return { ...this.goal };
+  }
+};
+var MCPClient = class {
+  config;
+  logger;
+  _serverName;
+  timeoutMs;
+  _tools = [];
+  _connected = false;
+  // stdio-specific state
+  process = null;
+  pendingCallbacks = /* @__PURE__ */ new Map();
+  requestId = 1;
+  stdioBuffer = "";
+  constructor(name, config, logger) {
+    this._serverName = name;
+    this.config = config;
+    this.logger = logger;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+  }
+  get serverName() {
+    return this._serverName;
+  }
+  get tools() {
+    return this._tools;
+  }
+  get isConnected() {
+    return this._connected;
+  }
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+  /**
+   * Connects to the MCP server: sends `initialize` + `notifications/initialized`,
+   * then fetches the tool list via `tools/list`.
+   */
+  async connect() {
+    this.logger.debug(`[MCP:${this._serverName}] Connecting via ${this.config.transport}...`);
+    if (this.config.transport === "stdio") {
+      await this._connectStdio();
+    } else {
+      if (!this.config.url) {
+        throw new LemuraMCPConnectionError(
+          `[MCP:${this._serverName}] 'url' is required for ${this.config.transport} transport`,
+          `No URL provided for MCP server '${this._serverName}'`,
+          [`Set 'url' in the MCPServerConfig for server '${this._serverName}'`]
+        );
+      }
+    }
+    await this._initialize();
+    await this._discoverTools();
+    this._connected = true;
+    this.logger.info(`[MCP:${this._serverName}] Connected. ${this._tools.length} tool(s) available.`);
+  }
+  /**
+   * Calls a tool on this MCP server.
+   *
+   * @param toolName - The tool name as declared by the server
+   * @param args - Tool arguments (must match the tool's inputSchema)
+   * @returns The serialised result from the server
+   */
+  async callTool(toolName, args) {
+    this.logger.debug(`[MCP:${this._serverName}] Calling tool '${toolName}'`, { args });
+    const request = {
+      jsonrpc: "2.0",
+      id: this._nextId(),
+      method: "tools/call",
+      params: { name: toolName, arguments: args }
+    };
+    const response = await this._rpc(request);
+    this._assertNoError(response, `tool '${toolName}'`);
+    const result = response.result;
+    if (result && Array.isArray(result["content"])) {
+      const texts = result["content"].filter((b) => b.type === "text" && b.text).map((b) => b.text);
+      return texts.length === 1 ? texts[0] : texts.length > 1 ? texts.join("\n") : result;
+    }
+    return result;
+  }
+  /**
+   * Disconnects from the MCP server.
+   * For stdio: sends the `exit` notification then terminates the process.
+   */
+  async disconnect() {
+    if (!this._connected) return;
+    this.logger.debug(`[MCP:${this._serverName}] Disconnecting...`);
+    this._connected = false;
+    if (this.process) {
+      try {
+        const exitNotif = JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/exit"
+        }) + "\n";
+        this.process.stdin?.write(exitNotif);
+      } catch {
+      }
+      this.process.kill();
+      this.process = null;
+    }
+    for (const [, cb] of this.pendingCallbacks) {
+      cb.reject(new LemuraMCPConnectionError(
+        `[MCP:${this._serverName}] Connection closed before response received`
+      ));
+    }
+    this.pendingCallbacks.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private: stdio transport
+  // ---------------------------------------------------------------------------
+  async _connectStdio() {
+    const { command, args = [], env = {} } = this.config;
+    if (!command) {
+      throw new LemuraMCPConnectionError(
+        `[MCP:${this._serverName}] 'command' is required for stdio transport`,
+        `No command provided for stdio MCP server '${this._serverName}'`,
+        [`Set the 'command' field in MCPServerConfig for server '${this._serverName}'`]
+      );
+    }
+    return new Promise((resolve, reject) => {
+      let proc;
+      try {
+        proc = child_process.spawn(command, args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: { ...process.env, ...env }
+        });
+      } catch (err) {
+        return reject(new LemuraMCPConnectionError(
+          `[MCP:${this._serverName}] Failed to spawn '${command}': ${err.message}`,
+          `Could not start MCP server process for '${this._serverName}'`,
+          [
+            `Ensure '${command}' is installed and available in PATH`,
+            `Check the 'args' and 'env' configuration for server '${this._serverName}'`
+          ]
+        ));
+      }
+      this.process = proc;
+      proc.on("error", (err) => {
+        this.logger.error(`[MCP:${this._serverName}] Process error: ${err.message}`);
+        for (const [, cb] of this.pendingCallbacks) {
+          cb.reject(new LemuraMCPConnectionError(
+            `[MCP:${this._serverName}] Process error: ${err.message}`
+          ));
+        }
+        this.pendingCallbacks.clear();
+        this._connected = false;
+      });
+      proc.on("exit", (code, signal) => {
+        if (this._connected) {
+          this.logger.warn(`[MCP:${this._serverName}] Process exited unexpectedly (code=${code}, signal=${signal})`);
+          this._connected = false;
+        }
+      });
+      proc.stdout?.on("data", (chunk) => {
+        this.stdioBuffer += chunk.toString("utf8");
+        this._flushStdioBuffer();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        this.logger.debug(`[MCP:${this._serverName}] stderr: ${chunk.toString("utf8").trim()}`);
+      });
+      resolve();
+    });
+  }
+  /** Parses newline-delimited JSON messages from the stdio buffer */
+  _flushStdioBuffer() {
+    const lines = this.stdioBuffer.split("\n");
+    this.stdioBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch {
+        this.logger.debug(`[MCP:${this._serverName}] Ignoring non-JSON line: ${trimmed.slice(0, 120)}`);
+        continue;
+      }
+      if (msg.id === void 0 || msg.id === null) continue;
+      const cb = this.pendingCallbacks.get(msg.id);
+      if (cb) {
+        this.pendingCallbacks.delete(msg.id);
+        cb.resolve(msg);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private: JSON-RPC helpers
+  // ---------------------------------------------------------------------------
+  _nextId() {
+    return this.requestId++;
+  }
+  /** Sends a JSON-RPC request and returns the response, honouring the configured timeout. */
+  async _rpc(request) {
+    if (this.config.transport === "stdio") {
+      return this._rpcStdio(request);
+    }
+    return this._rpcHttp(request);
+  }
+  _rpcStdio(request) {
+    return new Promise((resolve, reject) => {
+      if (!this.process?.stdin) {
+        return reject(new LemuraMCPConnectionError(
+          `[MCP:${this._serverName}] stdin is not available`
+        ));
+      }
+      const id = request.id;
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        this.pendingCallbacks.delete(id);
+        reject(new LemuraMCPTimeoutError(
+          `[MCP:${this._serverName}] RPC call '${request.method}' timed out after ${this.timeoutMs}ms`
+        ));
+      }, this.timeoutMs);
+      this.pendingCallbacks.set(id, {
+        resolve: (value) => {
+          if (timedOut) return;
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (err) => {
+          if (timedOut) return;
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+      this.process.stdin.write(JSON.stringify(request) + "\n", "utf8");
+    });
+  }
+  async _rpcHttp(request) {
+    const url = this.config.url;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Accept": "application/json" },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new LemuraMCPConnectionError(
+          `[MCP:${this._serverName}] HTTP ${res.status} from server: ${res.statusText}`,
+          `MCP server '${this._serverName}' returned a non-2xx response`,
+          [`Verify the server is running at '${url}' and accepting JSON-RPC requests`]
+        );
+      }
+      return await res.json();
+    } catch (err) {
+      if (err.name === "AbortError") {
+        throw new LemuraMCPTimeoutError(
+          `[MCP:${this._serverName}] HTTP RPC '${request.method}' timed out after ${this.timeoutMs}ms`
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Sends `initialize` then `notifications/initialized` per MCP spec */
+  async _initialize() {
+    const initRequest = {
+      jsonrpc: "2.0",
+      id: this._nextId(),
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        clientInfo: { name: "lemura", version: "1.2.0" }
+      }
+    };
+    let response;
+    try {
+      response = await this._rpc(initRequest);
+    } catch (err) {
+      const msg = err.message ?? String(err);
+      throw new LemuraMCPConnectionError(
+        `[MCP:${this._serverName}] Initialize failed: ${msg}`,
+        `Failed to initialize MCP server '${this._serverName}'`,
+        [
+          `Ensure the server supports the MCP protocol`,
+          `Verify the server is running and accepting connections`
+        ]
+      );
+    }
+    this._assertNoError(response, "initialize");
+    const initializedNotif = JSON.stringify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    }) + "\n";
+    if (this.config.transport === "stdio" && this.process?.stdin) {
+      this.process.stdin.write(initializedNotif, "utf8");
+    } else if (this.config.transport !== "stdio") {
+      fetch(this.config.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: initializedNotif
+      }).catch(() => {
+      });
+    }
+  }
+  /** Fetches and caches the tool list from the server */
+  async _discoverTools() {
+    const request = {
+      jsonrpc: "2.0",
+      id: this._nextId(),
+      method: "tools/list",
+      params: {}
+    };
+    const response = await this._rpc(request);
+    this._assertNoError(response, "tools/list");
+    const result = response.result;
+    const tools = result?.["tools"] ?? [];
+    this._tools = tools;
+  }
+  _assertNoError(response, context) {
+    if (response.error) {
+      throw new LemuraMCPConnectionError(
+        `[MCP:${this._serverName}] JSON-RPC error in ${context}: [${response.error.code}] ${response.error.message}`,
+        `MCP server '${this._serverName}' returned a JSON-RPC error during ${context}`,
+        ["Check the MCP server logs for more details"]
+      );
+    }
+  }
+};
+
+// src/mcp/MCPClientRegistry.ts
+var MCPClientRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  /** toolName → serverName  */
+  toolRouter = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  // ---------------------------------------------------------------------------
+  // Registration
+  // ---------------------------------------------------------------------------
+  /**
+   * Creates an `MCPClient` for the given config, connects to the server, and
+   * registers the server by name.
+   *
+   * @throws {LemuraMCPConnectionError} if connection / initialization fails
+   */
+  async register(name, config) {
+    if (this.clients.has(name)) {
+      this.logger.warn(`[MCPClientRegistry] Server '${name}' is already registered \u2014 skipping`);
+      return;
+    }
+    const client = new MCPClient(name, config, this.logger);
+    try {
+      await client.connect();
+    } catch (err) {
+      const msg = err.message ?? String(err);
+      throw new LemuraMCPConnectionError(
+        `[MCPClientRegistry] Failed to connect to server '${name}': ${msg}`,
+        `Could not establish connection to MCP server '${name}'`,
+        [
+          `Verify the server is reachable and the transport config is correct`,
+          `Check the 'command', 'args', or 'url' for server '${name}'`
+        ]
+      );
+    }
+    this.clients.set(name, client);
+    this.logger.info(`[MCPClientRegistry] Server '${name}' registered (${client.tools.length} tools)`);
+  }
+  // ---------------------------------------------------------------------------
+  // Tool discovery
+  // ---------------------------------------------------------------------------
+  /**
+   * Collects tools from all connected MCP servers and returns them as
+   * `IToolDefinition` adapters ready to be registered in `ToolRegistry`.
+   *
+   * Tool names are **not** namespaced — if two servers expose a tool with the
+   * same name, the last-registered server wins and a warning is emitted.
+   */
+  async discoverTools() {
+    const bridged = [];
+    for (const [serverName, client] of this.clients) {
+      for (const mcpTool of client.tools) {
+        if (this.toolRouter.has(mcpTool.name)) {
+          this.logger.warn(
+            `[MCPClientRegistry] Tool '${mcpTool.name}' is already provided by '${this.toolRouter.get(mcpTool.name)}'; overriding with server '${serverName}'`
+          );
+        }
+        this.toolRouter.set(mcpTool.name, serverName);
+        bridged.push(this._bridge(mcpTool, serverName));
+      }
+    }
+    this.logger.debug(`[MCPClientRegistry] Discovered ${bridged.length} total MCP tool(s)`);
+    return bridged;
+  }
+  // ---------------------------------------------------------------------------
+  // Routing
+  // ---------------------------------------------------------------------------
+  /**
+   * Calls a tool on the correct MCP server.
+   *
+   * @param toolName - The tool name as registered via `discoverTools()`
+   * @param args - Parsed arguments object
+   * @throws {LemuraMCPConnectionError} if no server is registered for `toolName`
+   */
+  async callTool(toolName, args) {
+    const serverName = this.toolRouter.get(toolName);
+    if (!serverName) {
+      throw new LemuraMCPConnectionError(
+        `[MCPClientRegistry] No MCP server found for tool '${toolName}'`,
+        `Tool '${toolName}' was not discovered from any connected MCP server`,
+        ["Verify the MCP server that provides this tool is configured and connected"]
+      );
+    }
+    const client = this.clients.get(serverName);
+    return client.callTool(toolName, args);
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Disconnects all registered MCP servers gracefully.
+   * Called automatically by `SessionManager.close()`.
+   */
+  async disconnectAll() {
+    const names = Array.from(this.clients.keys());
+    this.logger.debug(`[MCPClientRegistry] Disconnecting ${names.length} MCP server(s)...`);
+    await Promise.allSettled(
+      names.map(async (name) => {
+        try {
+          await this.clients.get(name).disconnect();
+          this.logger.debug(`[MCPClientRegistry] '${name}' disconnected`);
+        } catch (err) {
+          this.logger.warn(
+            `[MCPClientRegistry] Error disconnecting '${name}': ${err.message}`
+          );
+        }
+      })
+    );
+    this.clients.clear();
+    this.toolRouter.clear();
+  }
+  /** Returns the names of all currently registered servers */
+  getRegisteredServers() {
+    return Array.from(this.clients.keys());
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Bridges an `MCPToolDefinition` from the protocol into an `IToolDefinition`
+   * that the existing `ToolRegistry` can execute.
+   */
+  _bridge(mcpTool, serverName) {
+    const self = this;
+    return {
+      name: mcpTool.name,
+      description: `[MCP:${serverName}] ${mcpTool.description}`,
+      parameters: mcpTool.inputSchema ?? { type: "object", properties: {} },
+      async execute(params, _context) {
+        return self.callTool(mcpTool.name, params ?? {});
+      }
+    };
+  }
+};
+
+// src/agent/SessionManager.ts
+var SessionManager = class {
+  contextManager;
+  toolRegistry;
+  skillInjector;
+  context;
+  adapter;
+  config;
+  iterations = 0;
+  logger;
+  media;
+  // Advanced execution state
+  stepCounter;
+  toolResponseProcessor;
+  goalInjector = null;
+  continuationPlanner = null;
+  // MCP
+  mcpRegistry = null;
+  /** Resolves when all MCP servers are connected; used by run() and stream() */
+  mcpReady = null;
+  // Tool execution budget tracking
+  totalToolCallCount = 0;
+  perToolCallCount = /* @__PURE__ */ new Map();
+  totalTokens = 0;
+  constructor(config) {
+    this.config = config;
+    this.adapter = config.adapter;
+    this.logger = config.logger || new DefaultLogger();
+    this.contextManager = new ContextManager();
+    this.toolRegistry = new ToolRegistry(config.tools || [], {
+      defaultTimeoutMs: config.toolRegistryTimeoutMs ?? 3e4
+    });
+    this.skillInjector = new SkillInjector(config.skills || []);
+    this.media = new MediaBridge(this.adapter);
+    this.stepCounter = new StepCounter(config.maxSteps ?? 20);
+    this.toolResponseProcessor = config.toolResponseProcessor ?? new ToolResponseProcessor();
+    for (const strategy of config.compressionStrategies || []) {
+      this.contextManager.registerStrategy(strategy);
+    }
+    if (config.stmRegistry) {
+      this.toolRegistry.register(readChunkTool);
+      this.toolRegistry.register(searchChunkTool);
+      this.toolRegistry.register(listChunksTool);
+      this.toolRegistry.register(updateChunkTool);
+      this.toolRegistry.register(readScratchpadTool);
+      this.toolRegistry.register(writeScratchpadTool);
+      this.toolRegistry.register(removeScratchpadTool);
+      this.toolRegistry.register(summarizeSandwichTool);
+    }
+    if (config.media?.enableTools) {
+      const prefix = config.media.toolPrefix || "media_";
+      for (const tool of createMediaTools(prefix)) {
+        this.toolRegistry.register(tool);
+      }
+    }
+    this.context = {
+      systemPrompt: config.systemPrompt || "",
+      scratchpad: "",
+      turns: [],
+      tokenCount: 0,
+      maxTokens: config.maxTokens,
+      metadata: {}
+    };
+    this.goalInjector = null;
+    if (config.mcpServers && config.mcpServers.length > 0) {
+      this.mcpRegistry = new MCPClientRegistry(this.logger);
+      this.mcpReady = this._initMCP(config.mcpServers);
+    }
+    this.emitTrace("system", "session_init", {
+      config: {
+        model: this.config.model,
+        maxIterations: this.config.maxIterations,
+        maxSteps: this.config.maxSteps,
+        parallelToolCalls: this.config.parallelToolCalls,
+        enableGoalPlanning: this.config.enableGoalPlanning,
+        enableContinuationPlanning: this.config.enableContinuationPlanning
+      }
+    });
+  }
+  emitTrace(type, name, metadata, input, output, status = "done") {
+    if (this.config.onTrace) {
+      this.config.onTrace({
+        type,
+        name,
+        metadata: metadata || {},
+        input,
+        output,
+        status,
+        startedAt: Date.now()
+      });
+    }
+  }
+  /**
+   * Returns a shallow copy of the current context window.
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Returns the current conversation history.
+   */
+  getHistory() {
+    return [...this.context.turns];
+  }
+  /**
+   * Returns the `MediaBridge` for direct ASR / TTS / Vision / Image-gen calls.
+   */
+  getMedia() {
+    return this.media;
+  }
+  // -----------------------------------------------------------------------
+  // MCP initialisation
+  // -----------------------------------------------------------------------
+  /**
+   * Connects all configured MCP servers and registers their bridged tools.
+   * Called from the constructor as a fire-and-start async task; `run()` and
+   * `stream()` await `this.mcpReady` before executing.
+   */
+  async _initMCP(mcpServers) {
+    if (!this.mcpRegistry) return;
+    this.emitTrace("system", "mcp_init_start", { serverCount: mcpServers.length });
+    this.logger.info(`[MCP] Connecting to ${mcpServers.length} server(s)...`);
+    for (const serverConfig of mcpServers) {
+      try {
+        await this.mcpRegistry.register(serverConfig.name, serverConfig);
+        this.emitTrace("system", "mcp_server_connected", { server: serverConfig.name });
+      } catch (err) {
+        const msg = err.message ?? String(err);
+        this.logger.error(`[MCP] Failed to connect '${serverConfig.name}': ${msg}`);
+        this.emitTrace("error", "mcp_server_failed", { server: serverConfig.name, error: msg });
+      }
+    }
+    const bridgedTools = await this.mcpRegistry.discoverTools();
+    for (const tool of bridgedTools) {
+      try {
+        this.toolRegistry.register(tool);
+      } catch {
+        this.logger.warn(`[MCP] Tool '${tool.name}' conflicts with an existing tool \u2014 skipping`);
+      }
+    }
+    this.logger.info(`[MCP] ${bridgedTools.length} MCP tool(s) registered`);
+    this.emitTrace("system", "mcp_init_done", {
+      servers: this.mcpRegistry.getRegisteredServers(),
+      toolCount: bridgedTools.length
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  /** Builds the system prompt, injecting skills and goal if configured. */
+  buildSystemPrompt(userMessage) {
+    let prompt = this.context.systemPrompt || "";
+    if (this.config.enableGoalPlanning && userMessage) {
+      if (!this.goalInjector) {
+        this.goalInjector = new GoalInjector({
+          id: "main",
+          statement: typeof userMessage === "string" ? userMessage : "[multimodal]",
+          decomposition: [],
+          successCriteria: ["The user request is fully answered"],
+          injectionFrequency: this.config.goalInjectionFrequency ?? "always",
+          injectionPosition: this.config.goalInjectionPosition ?? "system_prompt"
+        });
+        this.logger.debug("Goal injector initialised");
+        const goal = this.goalInjector.getGoal();
+        this.emitTrace("planning", "goal_init", {
+          statement: goal.statement,
+          criteria: goal.successCriteria
+        });
+      }
+      if (this.config.goalInjectionPosition !== "pre_turn") {
+        prompt = this.goalInjector.injectInto(prompt);
+        this.emitTrace("planning", "goal_injected", { position: this.config.goalInjectionPosition || "system_prompt" });
+      }
+    }
+    const injectedSkills = this.skillInjector.buildInjectionBlock("system_prompt");
+    if (injectedSkills) {
+      prompt += "\n\n" + injectedSkills;
+    }
+    return prompt.trim();
+  }
+  /** Builds the messages array for the provider from the current context */
+  buildMessages(systemPrompt) {
+    const messages = this.context.turns.map((t) => ({
+      role: t.role,
+      content: t.content,
+      ...t.role === "tool" && t.toolResults?.[0] ? { name: t.toolResults[0].toolCallId } : {},
+      ...t.role === "assistant" && t.toolCalls ? { toolCalls: t.toolCalls } : {}
+    }));
+    if (systemPrompt) {
+      messages.unshift({ role: "system", content: systemPrompt });
+    }
+    if (this.goalInjector && this.config.goalInjectionPosition === "pre_turn") {
+      const goalBlock = this.goalInjector.injectInto("");
+      messages.push({ role: "system", content: goalBlock });
+      this.emitTrace("planning", "goal_injected", { position: "pre_turn" });
+    }
+    return messages;
+  }
+  /** Checks the tool execution budget and throws descriptively if exceeded */
+  checkExecutionBudget(toolName) {
+    const budget = this.config.toolExecutionBudget;
+    if (!budget) return;
+    if (budget.maxCallsPerSession !== void 0 && this.totalToolCallCount >= budget.maxCallsPerSession) {
+      const err = new LemuraMaxIterationsError(
+        `Tool execution budget exceeded: session limit of ${budget.maxCallsPerSession} tool calls reached`
+      );
+      this.logger.warn(err.message);
+      throw err;
+    }
+    if (budget.maxCallsPerTool?.[toolName] !== void 0) {
+      const current = this.perToolCallCount.get(toolName) ?? 0;
+      if (current >= (budget.maxCallsPerTool[toolName] ?? Infinity)) {
+        const err = new LemuraMaxIterationsError(
+          `Tool execution budget exceeded: '${toolName}' has reached its per-tool limit of ${budget.maxCallsPerTool[toolName]}`
+        );
+        this.logger.warn(err.message);
+        this.emitTrace("budget", "tool_limit_exceeded", { toolName, limit: budget.maxCallsPerTool[toolName], totalTokens: this.totalTokens });
+        throw err;
+      }
+    }
+    this.emitTrace("budget", "check_passed", {
+      toolName,
+      totalCalls: this.totalToolCallCount,
+      totalTokens: this.totalTokens,
+      tokenBudgetRemaining: this.config.maxTokens - this.totalTokens
+    });
+  }
+  /** Records a tool call in budget counters */
+  recordToolCall(toolName) {
+    this.totalToolCallCount++;
+    this.perToolCallCount.set(toolName, (this.perToolCallCount.get(toolName) ?? 0) + 1);
+  }
+  /**
+   * Processes a firewall decision for a tool call.
+   * Returns true to proceed, false to block.
+   */
+  async passesFirewall(toolName, argsJson, toolCallId, toolResults) {
+    const firewall = evaluateToolFirewall(
+      this.config.toolFirewall,
+      toolName,
+      argsJson,
+      this.logger
+    );
+    if (firewall.decision === "deny") {
+      this.logger.warn(`Tool blocked by firewall: ${toolName}`, { reason: firewall.reason });
+      toolResults.push({ toolCallId, content: `Blocked by tool firewall: ${firewall.reason}` });
+      return false;
+    }
+    if (firewall.decision === "ask") {
+      if (this.config.toolFirewall?.onAsk) {
+        const userDecision = await this.config.toolFirewall.onAsk(toolName, argsJson);
+        if (userDecision === "deny") {
+          this.logger.warn(`Tool blocked by firewall (ask \u2192 deny): ${toolName}`, { reason: firewall.reason });
+          toolResults.push({ toolCallId, content: `Blocked by tool firewall: ${firewall.reason}` });
+          return false;
+        }
+      } else {
+        this.logger.warn(`Tool blocked by firewall (ask without handler): ${toolName}`, { reason: firewall.reason });
+        toolResults.push({ toolCallId, content: `Blocked by tool firewall: ${firewall.reason}` });
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Executes a single parsed tool call and returns the serialised result string.
+   */
+  async executeSingleToolCall(tc) {
+    this.checkExecutionBudget(tc.name);
+    const args = JSON.parse(tc.arguments);
+    const executeContext = {
+      sessionId: "default",
+      turnIndex: this.context.turns.length,
+      logger: this.logger,
+      adapter: this.adapter,
+      stmRegistry: this.config.stmRegistry,
+      scratchpad: this.context.scratchpad
+    };
+    if (this.config.ragAdapter) {
+      executeContext["ragAdapter"] = this.config.ragAdapter;
+    }
+    this.logger.debug(`Executing tool: ${tc.name}`, { args: tc.arguments });
+    this.emitTrace("tool_call", tc.name, { id: tc.id }, tc.arguments, null, "running");
+    const result = await this.toolRegistry.execute(tc.name, args, executeContext);
+    this.recordToolCall(tc.name);
+    this.logger.debug(`Tool ${tc.name} returned successfully`);
+    let finalResult = result;
+    if (typeof result === "object" && result !== null) {
+      const resObj = result;
+      if (resObj["status"] === "success" && resObj["newScratchpad"] !== void 0) {
+        this.context.scratchpad = resObj["newScratchpad"];
+        finalResult = resObj["note"] || "Scratchpad updated";
+        this.emitTrace("planning", "scratchpad_update", { note: resObj["note"] });
+      }
+    }
+    let content = JSON.stringify(finalResult);
+    const tokenCount = this.adapter.estimateTokens(content);
+    if (this.config.maxTokensPerTool && tokenCount > this.config.maxTokensPerTool) {
+      content = content.slice(0, this.config.maxTokensPerTool * 4) + "... [TRUNCATED DUE TO TOOL TOKEN LIMIT]";
+    }
+    const toolDef = this.toolRegistry.get(tc.name) || {
+      name: tc.name,
+      description: "",
+      parameters: {},
+      execute: async () => void 0
+    };
+    const evaluation = this.toolResponseProcessor.evaluate(content, toolDef, this.context);
+    if (evaluation.shouldCompress && !evaluation.errorDetected) {
+      content = this.toolResponseProcessor.compress(content, evaluation);
+      this.emitTrace("compression", tc.name, { originalSize: evaluation.sizeClass }, null, content);
+    }
+    if (this.config.enableContinuationPlanning && evaluation.suggestedAction === "continue") {
+      this.emitTrace("planning", "continuation_detected", { toolName: tc.name, action: evaluation.suggestedAction });
+    }
+    this.emitTrace("tool_result", tc.name, { id: tc.id }, tc.arguments, content, "done");
+    return content;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Runs the full ReAct loop for a user message and returns the final assistant response.
+   *
+   * @param userMessage - The user's message (string or multimodal content blocks)
+   * @returns The assistant's final response string
+   * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
+   */
+  async run(userMessage) {
+    if (this.mcpReady) await this.mcpReady;
+    const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
+    this.logger.info(`Starting new session run`, {
+      model: this.config.model,
+      message: userMessageStr
+    });
+    const systemPrompt = this.buildSystemPrompt(userMessageStr);
+    this.context.turns.push({
+      role: "user",
+      content: userMessage,
+      tokenCount: Array.isArray(userMessage) ? userMessage.length * 50 : this.adapter.estimateTokens(userMessage),
+      turnIndex: this.context.turns.length,
+      compressed: false
+    });
+    const maxIts = this.config.maxIterations || 10;
+    this.iterations = 0;
+    this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
+    while (this.iterations < maxIts) {
+      this.iterations++;
+      this.logger.debug(`ReAct Iteration ${this.iterations}/${maxIts}`);
+      this.context = await this.contextManager.prepare(this.context);
+      let messages = this.buildMessages(systemPrompt);
+      if (this.stepCounter.isMaxReached()) {
+        this.logger.warn(`maxSteps (${this.config.maxSteps ?? 20}) reached \u2014 forcing final response`);
+        messages.push({
+          role: "system",
+          content: this.stepCounter.getForcedConclusionPrompt() + "\n\n" + FinalResponseFormatter.getRequiredStructure()
+        });
+        this.emitTrace("planning", "max_steps_reached", { maxSteps: this.config.maxSteps, currentSteps: this.stepCounter.count });
       }
       this.logger.debug(`Calling provider adapter (${this.adapter.name})...`);
+      this.emitTrace("thinking", "llm_call", {
+        model: this.config.model,
+        iteration: this.iterations,
+        totalTokens: this.totalTokens
+      }, null, null, "running");
       let response;
       try {
         response = await this.adapter.complete({
           model: this.config.model,
           messages,
-          tools: this.toolRegistry.getAll(),
+          tools: this.stepCounter.isMaxReached() ? [] : this.toolRegistry.getAll(),
           maxTokens: 1e3
-          // default gen tokens
         });
       } catch (err) {
-        const metadata = err.problem ? { problem: err.problem, hints: err.hints } : {};
-        this.logger.fatal(`Provider call failed: ${err.message}`, metadata);
+        const e = err;
+        const metadata = e.problem ? { problem: e.problem, hints: e.hints ?? [] } : {};
+        this.logger.fatal(`Provider call failed: ${e.message ?? String(err)}`, metadata);
+        this.emitTrace("error", "llm_call_failed", { error: e.message ?? String(err) });
         throw err;
       }
+      if (response.usage) {
+        this.totalTokens += response.usage.totalTokens;
+      }
+      this.emitTrace("thinking", "llm_call", {
+        model: this.config.model,
+        usage: response.usage,
+        totalTokens: this.totalTokens
+      }, null, response.content, "done");
       if (response.finishReason === "tool_call" && response.toolCalls) {
         this.logger.info(`Assistant requested ${response.toolCalls.length} tool calls`, {
           tools: response.toolCalls.map((tc) => tc.name)
         });
+        this.stepCounter.increment(response.toolCalls.length);
         const toolResults = [];
-        for (const tc of response.toolCalls) {
-          try {
-            const args = JSON.parse(tc.arguments);
-            const executeContext = {
-              sessionId: "default",
-              turnIndex: this.context.turns.length,
-              logger: this.logger,
-              stmRegistry: this.config.stmRegistry,
-              scratchpad: this.context.scratchpad
-            };
-            if (this.config.ragAdapter) {
-              executeContext.ragAdapter = this.config.ragAdapter;
-            }
-            this.logger.debug(`Executing tool: ${tc.name}`, { args: tc.arguments });
-            const result = await this.toolRegistry.execute(tc.name, args, executeContext);
-            this.logger.debug(`Tool ${tc.name} returned successfully`);
-            let finalResult = result;
-            if (typeof result === "object" && result !== null) {
-              const resObj = result;
-              if (resObj.status === "success" && resObj.newScratchpad !== void 0) {
-                this.context.scratchpad = resObj.newScratchpad;
-                finalResult = resObj.note || "Scratchpad updated";
-              }
-            }
-            let content = JSON.stringify(finalResult);
-            const tokenCount = this.adapter.estimateTokens(content);
-            if (this.config.maxTokensPerTool && tokenCount > this.config.maxTokensPerTool) {
-              content = content.slice(0, this.config.maxTokensPerTool * 4) + "... [TRUNCATED DUE TO TOOL TOKEN LIMIT]";
+        if (this.config.parallelToolCalls) {
+          const budget = this.config.toolExecutionBudget;
+          const maxConcurrent = budget?.maxConcurrentCalls ?? response.toolCalls.length;
+          for (let i = 0; i < response.toolCalls.length; i += maxConcurrent) {
+            const batch = response.toolCalls.slice(i, i + maxConcurrent);
+            const allowed = [];
+            for (const tc of batch) {
+              const ok = await this.passesFirewall(tc.name, tc.arguments, tc.id, toolResults);
+              if (ok) allowed.push(tc);
+              else this.emitTrace("budget", "firewall_blocked", { toolName: tc.name });
             }
-            toolResults.push({ toolCallId: tc.id, content });
-          } catch (e) {
-            this.logger.error(`Tool ${tc.name} execution failed: ${e.message}`, {
-              problem: e.problem || `Tool ${tc.name} failed to execute properly.`,
-              hints: e.hints || ["Check the tool parameters and ensure the required services are running."]
+            this.emitTrace("planning", "parallel_execution", {
+              batchSize: allowed.length,
+              totalInResponse: response.toolCalls.length
             });
-            toolResults.push({ toolCallId: tc.id, content: `Error: ${e.message}` });
+            const batchResults = await Promise.all(
+              allowed.map(async (tc) => {
+                try {
+                  const content = await this.executeSingleToolCall(tc);
+                  return { toolCallId: tc.id, content };
+                } catch (e) {
+                  const msg = e instanceof Error ? e.message : String(e);
+                  const isTimeout = e instanceof LemuraToolTimeoutError;
+                  this.logger.error(`Tool ${tc.name} ${isTimeout ? "timed out" : "failed"}: ${msg}`);
+                  return { toolCallId: tc.id, content: `Error: ${msg}` };
+                }
+              })
+            );
+            toolResults.push(...batchResults);
+          }
+        } else {
+          for (const tc of response.toolCalls) {
+            const ok = await this.passesFirewall(tc.name, tc.arguments, tc.id, toolResults);
+            if (!ok) continue;
+            try {
+              const content = await this.executeSingleToolCall(tc);
+              toolResults.push({ toolCallId: tc.id, content });
+            } catch (e) {
+              const msg = e instanceof Error ? e.message : String(e);
+              const isTimeout = e instanceof LemuraToolTimeoutError;
+              this.logger.error(`Tool ${tc.name} ${isTimeout ? "timed out" : "failed"}: ${msg}`, {
+                problem: `Tool ${tc.name} ${isTimeout ? "timed out" : "failed to execute"}.`,
+                hints: isTimeout ? ["Increase toolRegistryTimeoutMs or optimise the tool implementation."] : ["Check the tool parameters and ensure required services are running."]
+              });
+              toolResults.push({ toolCallId: tc.id, content: `Error: ${msg}` });
+            }
           }
         }
         const assistantTurn = {
           role: "assistant",
           content: response.content || "",
           tokenCount: this.adapter.estimateTokens(response.content || "") + 50,
-          // rough tool estimate
           turnIndex: this.context.turns.length,
           compressed: false,
           toolCalls: response.toolCalls
@@ -1208,61 +2497,194 @@ var SessionManager = class {
     const maxItsErr = new LemuraMaxIterationsError(`Exceeded max iterations of ${maxIts}`);
     this.logger.fatal(maxItsErr.message, {
       problem: "The agent entered an infinite loop or took too many steps to resolve the task.",
-      hints: ["Increase maxIterations if the task is complex.", "Check if tools are returning consistent results."]
+      hints: [
+        "Increase maxIterations if the task is complex.",
+        "Check if tools are returning consistent results."
+      ]
     });
     throw maxItsErr;
   }
-};
-
-// src/agent/execution/ToolResponseProcessor.ts
-var ToolResponseProcessor = class {
-  evaluate(response, tool, context) {
-    const length = response.length;
-    const estimatedTokens = length / 4;
-    let sizeClass = "small";
-    if (estimatedTokens > 2e3) sizeClass = "oversized";
-    else if (estimatedTokens > 800) sizeClass = "large";
-    else if (estimatedTokens > 200) sizeClass = "medium";
-    return {
-      relevanceScore: 1,
-      sizeClass,
-      shouldCompress: sizeClass === "large" || sizeClass === "oversized",
-      suggestedMaxTokens: 500,
-      answered: true,
-      answeredPartially: false,
-      errorDetected: response.toLowerCase().includes("error"),
-      suggestedAction: "continue"
-    };
-  }
-  compress(response, evaluation) {
-    if (!evaluation.shouldCompress || evaluation.errorDetected) {
-      return response;
-    }
-    if (response.length > 1e3) {
-      return response.substring(0, 1e3) + "\n...[COMPRESSED TO SAVE TOKENS]...";
+  /**
+   * Runs the ReAct loop and streams the final assistant response token-by-token.
+   *
+   * Tool calls within the loop are still executed synchronously (they must complete
+   * before streaming the conclusion). Only the final LLM text output is streamed.
+   *
+   * @param userMessage - The user's message (string or multimodal content blocks)
+   * @returns An `AsyncIterable<string>` of delta tokens from the final response
+   *
+   * @example
+   * for await (const token of session.stream('Tell me a story')) {
+   *   process.stdout.write(token);
+   * }
+   */
+  async *stream(userMessage) {
+    if (this.mcpReady) await this.mcpReady;
+    const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
+    this.logger.info(`Starting streaming session run`, {
+      model: this.config.model,
+      message: userMessageStr
+    });
+    const systemPrompt = this.buildSystemPrompt(userMessageStr);
+    this.context.turns.push({
+      role: "user",
+      content: userMessage,
+      tokenCount: Array.isArray(userMessage) ? userMessage.length * 50 : this.adapter.estimateTokens(userMessage),
+      turnIndex: this.context.turns.length,
+      compressed: false
+    });
+    const maxIts = this.config.maxIterations || 10;
+    this.iterations = 0;
+    this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
+    while (this.iterations < maxIts) {
+      this.iterations++;
+      this.logger.debug(`[stream] ReAct Iteration ${this.iterations}/${maxIts}`);
+      this.context = await this.contextManager.prepare(this.context);
+      const messages = this.buildMessages(systemPrompt);
+      if (this.stepCounter.isMaxReached()) {
+        messages.push({
+          role: "system",
+          content: this.stepCounter.getForcedConclusionPrompt() + "\n\n" + FinalResponseFormatter.getRequiredStructure()
+        });
+      }
+      let response;
+      try {
+        response = await this.adapter.complete({
+          model: this.config.model,
+          messages,
+          tools: this.stepCounter.isMaxReached() ? [] : this.toolRegistry.getAll(),
+          maxTokens: 1e3
+        });
+      } catch (err) {
+        this.logger.fatal(`Provider call failed: ${err.message}`);
+        throw err;
+      }
+      if (response.finishReason === "tool_call" && response.toolCalls) {
+        this.logger.info(`[stream] Tool calls: ${response.toolCalls.map((tc) => tc.name).join(", ")}`);
+        this.stepCounter.increment(response.toolCalls.length);
+        const toolResults = [];
+        for (const tc of response.toolCalls) {
+          const ok = await this.passesFirewall(tc.name, tc.arguments, tc.id, toolResults);
+          if (!ok) continue;
+          try {
+            const content = await this.executeSingleToolCall(tc);
+            toolResults.push({ toolCallId: tc.id, content });
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            toolResults.push({ toolCallId: tc.id, content: `Error: ${msg}` });
+          }
+        }
+        const assistantTurn = {
+          role: "assistant",
+          content: response.content || "",
+          tokenCount: this.adapter.estimateTokens(response.content || "") + 50,
+          turnIndex: this.context.turns.length,
+          compressed: false,
+          toolCalls: response.toolCalls
+        };
+        this.context.turns.push(assistantTurn);
+        if (this.config.onTurn) this.config.onTurn(assistantTurn);
+        for (const res of toolResults) {
+          const toolTurn = {
+            role: "tool",
+            content: res.content,
+            tokenCount: this.adapter.estimateTokens(res.content),
+            turnIndex: this.context.turns.length,
+            compressed: false,
+            toolResults: [res]
+          };
+          this.context.turns.push(toolTurn);
+          if (this.config.onTurn) this.config.onTurn(toolTurn);
+        }
+        continue;
+      }
+      this.context = await this.contextManager.prepare(this.context);
+      const finalMessages = this.buildMessages(systemPrompt);
+      let accumulated = "";
+      let finalFinishReason = void 0;
+      let finalTokenCount = 0;
+      for await (const chunk of this.adapter.stream({
+        model: this.config.model,
+        messages: finalMessages,
+        maxTokens: 1e3,
+        stream: true
+      })) {
+        if (chunk.delta) {
+          accumulated += chunk.delta;
+          finalTokenCount += Math.ceil(chunk.delta.length / 4);
+          yield chunk.delta;
+        }
+        if (chunk.finished) {
+          finalFinishReason = chunk.finishReason;
+          if (chunk.usage) {
+            this.totalTokens += chunk.usage.totalTokens;
+          }
+          this.emitTrace("thinking", "llm_stream_finished", {
+            usage: chunk.usage,
+            totalTokens: this.totalTokens,
+            finishReason: chunk.finishReason
+          });
+        }
+      }
+      const finalTurn = {
+        role: "assistant",
+        content: accumulated,
+        tokenCount: finalTokenCount,
+        turnIndex: this.context.turns.length,
+        compressed: false
+      };
+      this.context.turns.push(finalTurn);
+      if (this.config.onTurn) this.config.onTurn(finalTurn);
+      this.logger.info(`[stream] Streaming run completed (finishReason: ${finalFinishReason ?? "stop"})`);
+      return;
     }
-    return response;
+    const maxItsErr = new LemuraMaxIterationsError(`Exceeded max iterations of ${maxIts}`);
+    this.logger.fatal(maxItsErr.message, {
+      problem: "The streaming agent loop exceeded its max iterations.",
+      hints: ["Increase maxIterations or reduce task complexity."]
+    });
+    throw maxItsErr;
   }
-};
-
-// src/agent/execution/GoalInjector.ts
-var GoalInjector = class {
-  constructor(goal) {
-    this.goal = goal;
+  /**
+   * Resets the session: clears conversation history, resets iteration counters,
+   * and resets tool execution budgets. The adapter, config, and tools are retained.
+   */
+  reset() {
+    this.context = {
+      systemPrompt: this.config.systemPrompt || "",
+      scratchpad: "",
+      turns: [],
+      tokenCount: 0,
+      maxTokens: this.config.maxTokens,
+      metadata: {}
+    };
+    this.iterations = 0;
+    this.totalToolCallCount = 0;
+    this.perToolCallCount.clear();
+    this.stepCounter = new StepCounter(this.config.maxSteps ?? 20);
+    this.goalInjector = null;
+    this.logger.debug("Session reset");
   }
-  injectInto(prompt) {
-    const formatting = `[CURRENT GOAL]
-${this.goal.statement}
-
-Success criteria:
-${this.goal.successCriteria.map((c) => `- ${c}`).join("\n")}
-[/CURRENT GOAL]`;
-    if (this.goal.injectionPosition === "system_prompt") {
-      return `${prompt}
-
-${formatting}`;
+  /**
+   * Closes the session and disconnects all MCP servers.
+   *
+   * Call this when you are done with the session and have registered MCP servers,
+   * to ensure child processes are terminated and HTTP connections are released.
+   *
+   * @example
+   * const session = new SessionManager({ ..., mcpServers: [...] });
+   * try {
+   *   await session.run('Hello');
+   * } finally {
+   *   await session.close();
+   * }
+   */
+  async close() {
+    if (this.mcpRegistry) {
+      await this.mcpRegistry.disconnectAll();
+      this.emitTrace("system", "mcp_disconnected", {});
+      this.logger.debug("All MCP servers disconnected");
     }
-    return prompt;
   }
 };
 
@@ -1297,54 +2719,6 @@ var ContinuationPlanner = class {
   }
 };
 
-// src/agent/execution/StepCounter.ts
-var StepCounter = class {
-  constructor(maxSteps = 20) {
-    this.maxSteps = maxSteps;
-  }
-  toolCallCount = 0;
-  increment(count = 1) {
-    this.toolCallCount += count;
-  }
-  get count() {
-    return this.toolCallCount;
-  }
-  isMaxReached() {
-    return this.toolCallCount >= this.maxSteps;
-  }
-  getForcedConclusionPrompt() {
-    return `You have used ${this.toolCallCount}/${this.maxSteps} steps. Provide your final response now.
-Do not call any more tools. Use the required structure below.`;
-  }
-};
-
-// src/agent/execution/FinalResponseFormatter.ts
-var FinalResponseFormatter = class {
-  static getRequiredStructure() {
-    return `## Goal Status: [ACHIEVED | PARTIALLY_ACHIEVED | FAILED]
-
-### What was accomplished
-[Summary of completed work]
-
-### Remaining tasks
-[Bulleted list, or "None"]
-
-### Failed steps
-[Tool/step name + error context, or "None"]
-
-### Result
-[The actual answer or deliverable]`;
-  }
-  static validateStructure(response) {
-    if (!response.includes("## Goal Status:")) return false;
-    if (!response.includes("### What was accomplished")) return false;
-    if (!response.includes("### Remaining tasks")) return false;
-    if (!response.includes("### Failed steps")) return false;
-    if (!response.includes("### Result")) return false;
-    return true;
-  }
-};
-
 exports.ContextManager = ContextManager;
 exports.ContinuationPlanner = ContinuationPlanner;
 exports.DefaultLogger = DefaultLogger;
@@ -1356,12 +2730,18 @@ exports.InMemoryStorageAdapter = InMemoryStorageAdapter;
 exports.LemuraAdapterError = LemuraAdapterError;
 exports.LemuraContextOverflowError = LemuraContextOverflowError;
 exports.LemuraError = LemuraError;
+exports.LemuraMCPConnectionError = LemuraMCPConnectionError;
+exports.LemuraMCPError = LemuraMCPError;
+exports.LemuraMCPTimeoutError = LemuraMCPTimeoutError;
 exports.LemuraMaxIterationsError = LemuraMaxIterationsError;
 exports.LemuraSkillInjectionError = LemuraSkillInjectionError;
 exports.LemuraToolNotFoundError = LemuraToolNotFoundError;
 exports.LemuraToolTimeoutError = LemuraToolTimeoutError;
 exports.LemuraToolValidationError = LemuraToolValidationError;
 exports.LogLevel = LogLevel;
+exports.MCPClient = MCPClient;
+exports.MCPClientRegistry = MCPClientRegistry;
+exports.MediaBridge = MediaBridge;
 exports.OpenAICompatibleAdapter = OpenAICompatibleAdapter;
 exports.SandwichCompressionStrategy = SandwichCompressionStrategy;
 exports.ScratchpadStrategy = ScratchpadStrategy;
@@ -1371,5 +2751,7 @@ exports.SkillInjector = SkillInjector;
 exports.StepCounter = StepCounter;
 exports.ToolRegistry = ToolRegistry;
 exports.ToolResponseProcessor = ToolResponseProcessor;
+exports.evaluateToolFirewall = evaluateToolFirewall;
+exports.validateJsonSchema = validateJsonSchema;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map