@sschepis/oboto-agent 0.1.4 → 0.2.1

package/dist/index.js

@@ -1,8 +1,15 @@
 // src/oboto-agent.ts
-import { LScriptRuntime } from "@sschepis/lmscript";
+import {
+  LScriptRuntime,
+  MiddlewareManager,
+  ExecutionCache,
+  MemoryCacheBackend,
+  CostTracker,
+  RateLimiter,
+  AgentLoop
+} from "@sschepis/lmscript";
 import { aggregateStream } from "@sschepis/llm-wrapper";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { MessageRole as MessageRole2 } from "@sschepis/as-agent";
+import { MessageRole as MessageRole4 } from "@sschepis/as-agent";
 
 // src/event-bus.ts
 var AgentEventBus = class {
@@ -110,7 +117,7 @@ import { z as z2 } from "zod";
 var TriageSchema = z2.object({
   escalate: z2.boolean().describe("True if the request needs a powerful model, false if answerable directly"),
   reasoning: z2.string().describe("Brief explanation of the triage decision"),
-  directResponse: z2.string().optional().describe("Direct answer if the request can be handled without escalation")
+  directResponse: z2.string().nullish().transform((v) => v ?? void 0).describe("Direct answer if the request can be handled without escalation")
 });
 var TRIAGE_SYSTEM = `You are a fast triage classifier for an AI agent system.
 Your job is to decide whether a user's request can be answered directly (simple queries,
@@ -118,10 +125,13 @@ casual chat, short lookups) or needs to be escalated to a more powerful model
 (complex reasoning, multi-step tool usage, code generation, analysis).
 
 Rules:
-- If the request is a greeting, simple question, or casual conversation: respond directly.
+- Only respond directly for truly trivial exchanges: greetings, thanks, or very simple factual questions.
+- When responding directly, use a natural, warm, conversational tone. Do NOT list capabilities or describe what tools you have access to.
+- If the user's message could benefit from tool usage or detailed reasoning, always escalate.
 - If the request needs tool calls, code analysis, or multi-step reasoning: escalate.
 - If unsure, escalate. It's better to over-escalate than to give a poor direct answer.
 - Keep directResponse under 200 words when answering directly.
+- Pay attention to the recent context \u2014 if the user is continuing a conversation, your response should reflect that context.
 
 Respond with JSON matching the schema.`;
 function createTriageFunction(modelName) {
@@ -163,32 +173,38 @@ function createRouterTool(router, root) {
 }
 
 // src/adapters/llm-wrapper.ts
+function convertMessages(messages) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.filter((b) => b.type === "text").map((b) => b.text).join("\n")
+  }));
+}
+function convertTools(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function buildParams(request, tools) {
+  return {
+    model: request.model,
+    messages: convertMessages(request.messages),
+    temperature: request.temperature,
+    ...tools ? { tools } : {},
+    ...request.jsonMode ? { response_format: { type: "json_object" } } : {}
+  };
+}
 function toLmscriptProvider(provider, name) {
   return {
-    name: name ?? provider.providerName,
+    name: name ?? provider.providerName ?? "llm-wrapper",
     async chat(request) {
-      const messages = request.messages.map((m) => ({
-        role: m.role,
-        content: typeof m.content === "string" ? m.content : m.content.filter((b) => b.type === "text").map((b) => b.text).join("\n")
-      }));
-      let tools;
-      if (request.tools && request.tools.length > 0) {
-        tools = request.tools.map((t) => ({
-          type: "function",
-          function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
-          }
-        }));
-      }
-      const params = {
-        model: request.model,
-        messages,
-        temperature: request.temperature,
-        ...tools ? { tools } : {},
-        ...request.jsonMode ? { response_format: { type: "json_object" } } : {}
-      };
+      const tools = convertTools(request.tools);
+      const params = buildParams(request, tools);
       const response = await provider.chat(params);
       const choice = response.choices[0];
       let toolCalls;
@@ -208,6 +224,16 @@ function toLmscriptProvider(provider, name) {
         } : void 0,
         toolCalls
       };
+    },
+    async *chatStream(request) {
+      const tools = convertTools(request.tools);
+      const params = buildParams(request, tools);
+      for await (const chunk of provider.stream({ ...params, stream: true })) {
+        const delta = chunk.choices?.[0]?.delta;
+        if (delta?.content) {
+          yield delta.content;
+        }
+      }
     }
   };
 }
@@ -259,10 +285,848 @@ function createEmptySession() {
   return { version: 1, messages: [] };
 }
 
+// src/adapters/rag-integration.ts
+import {
+  RAGPipeline,
+  MemoryVectorStore
+} from "@sschepis/lmscript";
+import { MessageRole as MessageRole2 } from "@sschepis/as-agent";
+var ConversationRAG = class {
+  vectorStore;
+  embeddingProvider;
+  ragPipeline;
+  config;
+  indexedMessageCount = 0;
+  runtime;
+  constructor(runtime, config) {
+    this.runtime = runtime;
+    this.vectorStore = config.vectorStore ?? new MemoryVectorStore();
+    this.embeddingProvider = config.embeddingProvider;
+    this.config = {
+      embeddingProvider: config.embeddingProvider,
+      vectorStore: this.vectorStore,
+      topK: config.topK ?? 5,
+      minScore: config.minScore ?? 0.3,
+      embeddingModel: config.embeddingModel ?? "",
+      autoIndex: config.autoIndex ?? true,
+      indexToolResults: config.indexToolResults ?? true,
+      maxChunkSize: config.maxChunkSize ?? 2e3,
+      formatContext: config.formatContext ?? defaultConversationContextFormatter
+    };
+    this.ragPipeline = new RAGPipeline(runtime, {
+      embeddingProvider: this.embeddingProvider,
+      vectorStore: this.vectorStore,
+      topK: this.config.topK,
+      minScore: this.config.minScore,
+      embeddingModel: this.config.embeddingModel,
+      formatContext: this.config.formatContext
+    });
+  }
+  // ── Indexing ──────────────────────────────────────────────────────
+  /**
+   * Index an entire as-agent Session into the vector store.
+   * Each message becomes one or more chunks (split by maxChunkSize).
+   */
+  async indexSession(session) {
+    const documents = [];
+    for (let i = 0; i < session.messages.length; i++) {
+      const msg = session.messages[i];
+      const chunks = this.messageToChunks(msg, i);
+      documents.push(...chunks);
+    }
+    if (documents.length > 0) {
+      await this.ragPipeline.ingest(documents);
+      this.indexedMessageCount += session.messages.length;
+    }
+    return documents.length;
+  }
+  /**
+   * Index a single conversation message.
+   * Call this after adding a message to the session for real-time indexing.
+   */
+  async indexMessage(msg, messageIndex) {
+    const idx = messageIndex ?? this.indexedMessageCount;
+    const chunks = this.messageToChunks(msg, idx);
+    if (chunks.length > 0) {
+      await this.ragPipeline.ingest(chunks);
+      this.indexedMessageCount++;
+    }
+  }
+  /**
+   * Index a tool execution result for later retrieval.
+   */
+  async indexToolResult(command, kwargs, result) {
+    if (!this.config.indexToolResults) return;
+    const content = `Tool: ${command}
+Args: ${JSON.stringify(kwargs)}
+Result: ${result}`;
+    const chunks = this.splitChunks(content, `tool:${command}:${Date.now()}`);
+    if (chunks.length > 0) {
+      const documents = chunks.map((chunk, i) => ({
+        id: chunk.id,
+        content: chunk.content,
+        metadata: {
+          type: "tool_result",
+          command,
+          kwargs,
+          chunkIndex: i,
+          timestamp: Date.now()
+        }
+      }));
+      await this.ragPipeline.ingest(documents);
+    }
+  }
+  // ── Retrieval ─────────────────────────────────────────────────────
+  /**
+   * Retrieve relevant past context for a query.
+   * Returns formatted context string and raw results.
+   */
+  async retrieve(query) {
+    const [queryVector] = await this.embeddingProvider.embed(
+      [query],
+      this.config.embeddingModel || void 0
+    );
+    const results = await this.vectorStore.search(queryVector, this.config.topK);
+    const filtered = results.filter((r) => r.score >= this.config.minScore);
+    const context = this.config.formatContext(filtered);
+    const totalDocuments = await this.vectorStore.count();
+    return { context, results: filtered, totalDocuments };
+  }
+  /**
+   * Execute an lmscript function with RAG-augmented context from the
+   * conversation history.
+   *
+   * This is the primary integration point — it uses lmscript's RAGPipeline
+   * to inject relevant past conversation into the function's system prompt.
+   */
+  async executeWithContext(fn, input, queryText) {
+    const ragResult = await this.ragPipeline.query(fn, input, queryText);
+    return {
+      result: ragResult.result,
+      retrievedDocuments: ragResult.retrievedDocuments,
+      context: ragResult.context
+    };
+  }
+  // ── Utility ───────────────────────────────────────────────────────
+  /** Get the number of indexed messages. */
+  get messageCount() {
+    return this.indexedMessageCount;
+  }
+  /** Get the total number of document chunks in the vector store. */
+  async documentCount() {
+    return this.vectorStore.count();
+  }
+  /** Clear the vector store and reset counters. */
+  async clear() {
+    await this.vectorStore.clear();
+    this.indexedMessageCount = 0;
+  }
+  /** Get the underlying vector store (for advanced usage). */
+  getVectorStore() {
+    return this.vectorStore;
+  }
+  /** Get the underlying RAG pipeline (for advanced usage). */
+  getRagPipeline() {
+    return this.ragPipeline;
+  }
+  // ── Private ───────────────────────────────────────────────────────
+  messageToChunks(msg, messageIndex) {
+    const roleLabel = messageRoleToLabel(msg.role);
+    const text = blocksToText2(msg.blocks);
+    if (!text.trim()) return [];
+    const prefixed = `[${roleLabel}]: ${text}`;
+    const baseId = `msg:${messageIndex}`;
+    return this.splitChunks(prefixed, baseId).map((chunk, i) => ({
+      id: chunk.id,
+      content: chunk.content,
+      metadata: {
+        type: "conversation",
+        role: roleLabel,
+        messageIndex,
+        chunkIndex: i,
+        timestamp: Date.now()
+      }
+    }));
+  }
+  splitChunks(text, baseId) {
+    const maxSize = this.config.maxChunkSize;
+    if (text.length <= maxSize) {
+      return [{ id: baseId, content: text }];
+    }
+    const chunks = [];
+    let remaining = text;
+    let chunkIdx = 0;
+    while (remaining.length > 0) {
+      let splitAt = maxSize;
+      if (remaining.length > maxSize) {
+        const paraIdx = remaining.lastIndexOf("\n\n", maxSize);
+        if (paraIdx > maxSize * 0.3) {
+          splitAt = paraIdx + 2;
+        } else {
+          const sentIdx = remaining.lastIndexOf(". ", maxSize);
+          if (sentIdx > maxSize * 0.3) {
+            splitAt = sentIdx + 2;
+          }
+        }
+      } else {
+        splitAt = remaining.length;
+      }
+      chunks.push({
+        id: `${baseId}:${chunkIdx}`,
+        content: remaining.slice(0, splitAt).trim()
+      });
+      remaining = remaining.slice(splitAt);
+      chunkIdx++;
+    }
+    return chunks;
+  }
+};
+function messageRoleToLabel(role) {
+  switch (role) {
+    case MessageRole2.System:
+      return "system";
+    case MessageRole2.User:
+      return "user";
+    case MessageRole2.Assistant:
+      return "assistant";
+    case MessageRole2.Tool:
+      return "tool";
+    default:
+      return "unknown";
+  }
+}
+function blocksToText2(blocks) {
+  return blocks.map((b) => {
+    switch (b.kind) {
+      case "text":
+        return b.text;
+      case "tool_use":
+        return `[Tool: ${b.name}(${b.input})]`;
+      case "tool_result":
+        return b.isError ? `[Error: ${b.toolName}: ${b.output}]` : `[Result: ${b.toolName}: ${b.output}]`;
+      default:
+        return "";
+    }
+  }).join("\n");
+}
+function defaultConversationContextFormatter(results) {
+  if (results.length === 0) return "";
+  return [
+    "## Relevant Past Context",
+    "",
+    ...results.map((r, i) => {
+      const meta = r.document.metadata;
+      const type = meta?.type ?? "unknown";
+      const score = r.score.toFixed(3);
+      return `[${i + 1}] (${type}, score: ${score})
+${r.document.content}`;
+    })
+  ].join("\n");
+}
+
+// src/adapters/as-agent-features.ts
+import { MessageRole as MessageRole3 } from "@sschepis/as-agent";
+var PermissionGuard = class {
+  constructor(policy, prompter, bus) {
+    this.policy = policy;
+    this.prompter = prompter;
+    this.bus = bus;
+  }
+  policy;
+  prompter;
+  bus;
+  /**
+   * Check whether a tool call is authorized.
+   * Emits `permission_denied` on the event bus if denied.
+   */
+  checkPermission(toolName, toolInput) {
+    const outcome = this.policy.authorize(toolName, toolInput, this.prompter);
+    if (outcome.kind === "deny") {
+      this.bus?.emit("permission_denied", {
+        toolName,
+        toolInput,
+        reason: outcome.reason ?? "denied by policy",
+        activeMode: this.policy.activeMode,
+        requiredMode: this.policy.requiredModeFor(toolName)
+      });
+    }
+    return outcome;
+  }
+  /** Get the current active permission mode. */
+  get activeMode() {
+    return this.policy.activeMode;
+  }
+  /** Get the required permission mode for a specific tool. */
+  requiredModeFor(toolName) {
+    return this.policy.requiredModeFor(toolName);
+  }
+};
+var SessionCompactor = class {
+  config;
+  bus;
+  compactionCount = 0;
+  totalRemovedMessages = 0;
+  constructor(bus, config) {
+    this.bus = bus;
+    this.config = config;
+  }
+  /**
+   * Check if the session needs compaction and perform it if so.
+   * Uses a simple heuristic: ~4 chars per token for estimation.
+   *
+   * Since the actual compaction logic lives in the Wasm runtime
+   * (ConversationRuntime.compact()), this method provides a JS-side
+   * implementation that creates a summary of older messages and
+   * preserves recent ones.
+   *
+   * Returns null if compaction is not needed.
+   */
+  compactIfNeeded(session, estimatedTokens) {
+    const tokenEstimate = estimatedTokens ?? this.estimateTokens(session);
+    if (tokenEstimate <= this.config.maxEstimatedTokens) {
+      return null;
+    }
+    return this.compact(session);
+  }
+  /**
+   * Force compaction of the session regardless of token count.
+   */
+  compact(session) {
+    const preserve = this.config.preserveRecentMessages;
+    const totalMessages = session.messages.length;
+    if (totalMessages <= preserve) {
+      return {
+        summary: "",
+        formattedSummary: "",
+        compactedSession: session,
+        removedMessageCount: 0
+      };
+    }
+    const toSummarize = session.messages.slice(0, totalMessages - preserve);
+    const toPreserve = session.messages.slice(totalMessages - preserve);
+    const summaryParts = [];
+    for (const msg of toSummarize) {
+      const role = roleToString(msg.role);
+      const text = blocksToText3(msg.blocks);
+      if (text.trim()) {
+        summaryParts.push(`[${role}]: ${text}`);
+      }
+    }
+    const summary = summaryParts.join("\n\n");
+    const formattedSummary = `[Session Compaction Summary \u2014 ${toSummarize.length} messages summarized]
+
+${summary}`;
+    const summaryMessage = {
+      role: MessageRole3.System,
+      blocks: [{
+        kind: "text",
+        text: `[Previous conversation summary \u2014 ${toSummarize.length} messages compacted]
+
+${summary.length > 4e3 ? summary.slice(0, 4e3) + "\n\n[... summary truncated]" : summary}`
+      }]
+    };
+    const compactedSession = {
+      version: session.version,
+      messages: [summaryMessage, ...toPreserve]
+    };
+    const result = {
+      summary,
+      formattedSummary,
+      compactedSession,
+      removedMessageCount: toSummarize.length
+    };
+    this.compactionCount++;
+    this.totalRemovedMessages += toSummarize.length;
+    this.bus?.emit("session_compacted", {
+      removedMessageCount: toSummarize.length,
+      preservedMessageCount: toPreserve.length + 1,
+      // +1 for summary msg
+      estimatedTokensBefore: this.estimateTokens(session),
+      estimatedTokensAfter: this.estimateTokens(compactedSession),
+      compactionIndex: this.compactionCount
+    });
+    return result;
+  }
+  /** Get compaction statistics. */
+  get stats() {
+    return {
+      compactionCount: this.compactionCount,
+      totalRemovedMessages: this.totalRemovedMessages
+    };
+  }
+  /** Update the compaction config at runtime. */
+  updateConfig(config) {
+    if (config.preserveRecentMessages !== void 0) {
+      this.config.preserveRecentMessages = config.preserveRecentMessages;
+    }
+    if (config.maxEstimatedTokens !== void 0) {
+      this.config.maxEstimatedTokens = config.maxEstimatedTokens;
+    }
+  }
+  /** Estimate token count for a session (~4 chars per token). */
+  estimateTokens(session) {
+    let charCount = 0;
+    for (const msg of session.messages) {
+      for (const block of msg.blocks) {
+        if (block.kind === "text") {
+          charCount += block.text.length;
+        } else if (block.kind === "tool_use") {
+          charCount += block.name.length + block.input.length;
+        } else if (block.kind === "tool_result") {
+          charCount += block.output.length;
+        }
+      }
+    }
+    return Math.ceil(charCount / 4);
+  }
+};
+var HookIntegration = class {
+  constructor(runner, bus) {
+    this.runner = runner;
+    this.bus = bus;
+  }
+  runner;
+  bus;
+  /**
+   * Run pre-tool-use hooks. If any hook denies the call,
+   * the tool execution should be skipped.
+   */
+  runPreToolUse(toolName, toolInput) {
+    const result = this.runner.runPreToolUse(toolName, toolInput);
+    if (result.denied) {
+      this.bus?.emit("hook_denied", {
+        phase: "pre",
+        toolName,
+        toolInput,
+        messages: result.messages
+      });
+    } else if (result.messages.length > 0) {
+      this.bus?.emit("hook_message", {
+        phase: "pre",
+        toolName,
+        messages: result.messages
+      });
+    }
+    return result;
+  }
+  /**
+   * Run post-tool-use hooks. These can log, transform, or audit
+   * tool results but cannot retroactively deny execution.
+   */
+  runPostToolUse(toolName, toolInput, toolOutput, isError) {
+    const result = this.runner.runPostToolUse(toolName, toolInput, toolOutput, isError);
+    if (result.messages.length > 0) {
+      this.bus?.emit("hook_message", {
+        phase: "post",
+        toolName,
+        messages: result.messages
+      });
+    }
+    return result;
+  }
+};
+var SlashCommandRegistry = class {
+  customCommands = /* @__PURE__ */ new Map();
+  wasmRuntime;
+  constructor(wasmRuntime) {
+    this.wasmRuntime = wasmRuntime;
+  }
+  /**
+   * Get all slash command specs (built-in from Wasm + custom).
+   */
+  getCommandSpecs() {
+    const builtIn = this.wasmRuntime ? this.wasmRuntime.slashCommandSpecs() : [];
+    const custom = Array.from(this.customCommands.values()).map((c) => c.spec);
+    return [...builtIn, ...custom];
+  }
+  /**
+   * Get the full help text for all commands.
+   * Uses the Wasm runtime's formatted help if available.
+   */
+  getHelpText() {
+    const parts = [];
+    if (this.wasmRuntime) {
+      parts.push(this.wasmRuntime.renderSlashCommandHelp());
+    }
+    if (this.customCommands.size > 0) {
+      parts.push("\n## Custom Commands\n");
+      for (const [name, { spec }] of this.customCommands) {
+        const hint = spec.argumentHint ? ` ${spec.argumentHint}` : "";
+        parts.push(`/${name}${hint} \u2014 ${spec.summary}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Register a custom slash command.
+   */
+  registerCommand(spec, handler) {
+    this.customCommands.set(spec.name, { spec, handler });
+  }
+  /**
+   * Unregister a custom slash command.
+   */
+  unregisterCommand(name) {
+    return this.customCommands.delete(name);
+  }
+  /**
+   * Parse a user input string to check if it's a slash command.
+   * Returns the command name and arguments, or null if not a command.
+   */
+  parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) return null;
+    const spaceIdx = trimmed.indexOf(" ");
+    const name = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+    const args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1).trim();
+    return { name, args };
+  }
+  /**
+   * Execute a custom slash command by name.
+   * Returns the command output, or null if the command is not found
+   * in the custom registry (it may be a built-in Wasm command).
+   */
+  async executeCustomCommand(name, args) {
+    const entry = this.customCommands.get(name);
+    if (!entry) return null;
+    return entry.handler(args);
+  }
+  /**
+   * Check if a command name exists (either built-in or custom).
+   */
+  hasCommand(name) {
+    if (this.customCommands.has(name)) return true;
+    const specs = this.getCommandSpecs();
+    return specs.some((s) => s.name === name);
+  }
+  /**
+   * Get only commands that support resume (useful for session restoration).
+   */
+  getResumeSupportedCommands() {
+    const builtIn = this.wasmRuntime ? this.wasmRuntime.resumeSupportedSlashCommands() : [];
+    const custom = Array.from(this.customCommands.values()).filter((c) => c.spec.resumeSupported).map((c) => c.spec);
+    return [...builtIn, ...custom];
+  }
+};
+var AgentUsageTracker = class {
+  turnUsages = [];
+  currentTurn = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0
+  };
+  record(usage) {
+    this.currentTurn = {
+      inputTokens: this.currentTurn.inputTokens + usage.inputTokens,
+      outputTokens: this.currentTurn.outputTokens + usage.outputTokens,
+      cacheCreationInputTokens: this.currentTurn.cacheCreationInputTokens + usage.cacheCreationInputTokens,
+      cacheReadInputTokens: this.currentTurn.cacheReadInputTokens + usage.cacheReadInputTokens
+    };
+  }
+  currentTurnUsage() {
+    return { ...this.currentTurn };
+  }
+  cumulativeUsage() {
+    const cumulative = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0
+    };
+    for (const usage of this.turnUsages) {
+      cumulative.inputTokens += usage.inputTokens;
+      cumulative.outputTokens += usage.outputTokens;
+      cumulative.cacheCreationInputTokens += usage.cacheCreationInputTokens;
+      cumulative.cacheReadInputTokens += usage.cacheReadInputTokens;
+    }
+    cumulative.inputTokens += this.currentTurn.inputTokens;
+    cumulative.outputTokens += this.currentTurn.outputTokens;
+    cumulative.cacheCreationInputTokens += this.currentTurn.cacheCreationInputTokens;
+    cumulative.cacheReadInputTokens += this.currentTurn.cacheReadInputTokens;
+    return cumulative;
+  }
+  turns() {
+    return this.turnUsages.length + (this.hasTurnActivity() ? 1 : 0);
+  }
+  /**
+   * Finalize the current turn and start a new one.
+   * Call this at the end of each agent turn.
+   */
+  endTurn() {
+    if (this.hasTurnActivity()) {
+      this.turnUsages.push({ ...this.currentTurn });
+      this.currentTurn = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 0
+      };
+    }
+  }
+  /** Reset all usage data. */
+  reset() {
+    this.turnUsages = [];
+    this.currentTurn = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0
+    };
+  }
+  hasTurnActivity() {
+    return this.currentTurn.inputTokens > 0 || this.currentTurn.outputTokens > 0;
+  }
+};
+function roleToString(role) {
+  switch (role) {
+    case MessageRole3.System:
+      return "system";
+    case MessageRole3.User:
+      return "user";
+    case MessageRole3.Assistant:
+      return "assistant";
+    case MessageRole3.Tool:
+      return "tool";
+    default:
+      return "unknown";
+  }
+}
+function blocksToText3(blocks) {
+  return blocks.map((b) => {
+    switch (b.kind) {
+      case "text":
+        return b.text;
+      case "tool_use":
+        return `[Tool: ${b.name}(${b.input})]`;
+      case "tool_result":
+        return b.isError ? `[Error: ${b.toolName}: ${b.output}]` : `[Result: ${b.toolName}: ${b.output}]`;
+      default:
+        return "";
+    }
+  }).join("\n");
+}
+
+// src/adapters/router-events.ts
+var ROUTER_EVENTS = [
+  "route",
+  "fallback",
+  "circuit:open",
+  "circuit:close",
+  "circuit:half-open",
+  "request:complete",
+  "request:error"
+];
+var RouterEventBridge = class {
+  bus;
+  attachedRouters = /* @__PURE__ */ new Map();
+  constructor(bus) {
+    this.bus = bus;
+  }
+  /**
+   * Attach an LLMRouter and forward all its events to the agent bus.
+   *
+   * @param router - The LLMRouter to monitor
+   * @param label - A label to identify this router in events (e.g. "local", "remote")
+   */
+  attach(router, label) {
+    this.detach(label);
+    const detachFns = [];
+    for (const eventName of ROUTER_EVENTS) {
+      const handler = (data) => {
+        this.bus.emit("router_event", {
+          routerLabel: label,
+          eventName,
+          data,
+          timestamp: Date.now()
+        });
+      };
+      router.events.on(eventName, handler);
+      detachFns.push(() => {
+        router.events.off(eventName, handler);
+      });
+    }
+    this.attachedRouters.set(label, { router, detachFns });
+  }
+  /**
+   * Detach a previously attached router.
+   */
+  detach(label) {
+    const entry = this.attachedRouters.get(label);
+    if (entry) {
+      for (const fn of entry.detachFns) {
+        fn();
+      }
+      this.attachedRouters.delete(label);
+    }
+  }
+  /**
+   * Detach all attached routers.
+   */
+  detachAll() {
+    for (const label of this.attachedRouters.keys()) {
+      this.detach(label);
+    }
+  }
+  /**
+   * Get a health snapshot from all attached routers.
+   * Returns a map of router label -> endpoint name -> HealthState.
+   */
+  getHealthSnapshot() {
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [label, { router }] of this.attachedRouters) {
+      snapshot.set(label, router.getHealthState());
+    }
+    return snapshot;
+  }
+  /**
+   * Check if any attached router has an endpoint in "open" (tripped) circuit state.
+   */
+  hasTrippedCircuits() {
+    for (const [, { router }] of this.attachedRouters) {
+      for (const [, health] of router.getHealthState()) {
+        if (health.status === "open") return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the labels of all attached routers.
+   */
+  get labels() {
+    return Array.from(this.attachedRouters.keys());
+  }
+};
+function isLLMRouter(provider) {
+  return typeof provider === "object" && provider !== null && "events" in provider && "getHealthState" in provider;
+}
+
+// src/adapters/usage-bridge.ts
+function asTokenUsageToLmscript(usage) {
+  const promptTokens = usage.inputTokens;
+  const completionTokens = usage.outputTokens;
+  const totalTokens = usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+  return { promptTokens, completionTokens, totalTokens };
+}
+function lmscriptToAsTokenUsage(usage) {
+  return {
+    inputTokens: usage.promptTokens,
+    outputTokens: usage.completionTokens,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0
+  };
+}
+function estimateCostFromAsAgent(usage, pricing) {
+  const inputCostUsd = usage.inputTokens / 1e6 * pricing.inputCostPerMillion;
+  const outputCostUsd = usage.outputTokens / 1e6 * pricing.outputCostPerMillion;
+  const cacheCreationCostUsd = usage.cacheCreationInputTokens / 1e6 * pricing.cacheCreationCostPerMillion;
+  const cacheReadCostUsd = usage.cacheReadInputTokens / 1e6 * pricing.cacheReadCostPerMillion;
+  const totalCostUsd = inputCostUsd + outputCostUsd + cacheCreationCostUsd + cacheReadCostUsd;
+  return {
+    inputCostUsd,
+    outputCostUsd,
+    cacheCreationCostUsd,
+    cacheReadCostUsd,
+    totalCostUsd
+  };
+}
+var UsageBridge = class {
+  constructor(asTracker, lmTracker) {
+    this.asTracker = asTracker;
+    this.lmTracker = lmTracker;
+  }
+  asTracker;
+  lmTracker;
+  /**
+   * Record usage from an lmscript-format source (e.g. from the streaming path
+   * or AgentLoop result).
+   *
+   * Converts to as-agent format and records in both trackers.
+   */
+  recordFromLmscript(functionName, usage) {
+    this.lmTracker?.trackUsage(functionName, usage);
+    this.asTracker.record(lmscriptToAsTokenUsage(usage));
+  }
+  /**
+   * Record usage from an as-agent-format source (e.g. from ConversationRuntime
+   * or the Wasm runtime).
+   *
+   * Converts to lmscript format and records in both trackers.
+   */
+  recordFromAsAgent(usage, functionName) {
+    this.asTracker.record(usage);
+    if (this.lmTracker) {
+      this.lmTracker.trackUsage(
+        functionName ?? "as-agent",
+        asTokenUsageToLmscript(usage)
+      );
+    }
+  }
+  /**
+   * End the current turn in the as-agent tracker.
+   */
+  endTurn() {
+    this.asTracker.endTurn();
+  }
+  /**
+   * Get unified cost summary combining both tracking systems.
+   */
+  getCostSummary(lmPricing, asPricing) {
+    const asUsage = this.asTracker.cumulativeUsage();
+    const asTurns = this.asTracker.turns();
+    let asCostEstimate;
+    if (asPricing) {
+      asCostEstimate = estimateCostFromAsAgent(asUsage, asPricing);
+    }
+    let lmTotalTokens;
+    let lmTotalCost;
+    let lmByFunction;
+    if (this.lmTracker) {
+      lmTotalTokens = this.lmTracker.getTotalTokens();
+      lmTotalCost = this.lmTracker.getTotalCost(lmPricing);
+      const usageMap = this.lmTracker.getUsageByFunction();
+      lmByFunction = {};
+      for (const [fnName, entry] of usageMap) {
+        lmByFunction[fnName] = entry;
+      }
+    }
+    return {
+      // as-agent view
+      asAgent: {
+        usage: asUsage,
+        turns: asTurns,
+        costEstimate: asCostEstimate
+      },
+      // lmscript view
+      lmscript: this.lmTracker ? {
+        totalTokens: lmTotalTokens,
+        totalCost: lmTotalCost,
+        byFunction: lmByFunction
+      } : void 0
+    };
+  }
+  /**
+   * Reset both tracking systems.
+   */
+  reset() {
+    this.asTracker.reset();
+    this.lmTracker?.reset();
+  }
+  /** Get the as-agent usage tracker. */
+  getAsTracker() {
+    return this.asTracker;
+  }
+  /** Get the lmscript cost tracker (if available). */
+  getLmTracker() {
+    return this.lmTracker;
+  }
+};
+
 // src/oboto-agent.ts
-var ObotoAgent = class _ObotoAgent {
+var ObotoAgent = class {
   bus = new AgentEventBus();
   localRuntime;
+  remoteRuntime;
   localProvider;
   remoteProvider;
   contextManager;
@@ -275,12 +1139,54 @@ var ObotoAgent = class _ObotoAgent {
   maxIterations;
   config;
   onToken;
+  costTracker;
+  modelPricing;
+  rateLimiter;
+  middleware;
+  budget;
+  conversationRAG;
+  permissionGuard;
+  sessionCompactor;
+  hookIntegration;
+  slashCommands;
+  usageTracker;
+  usageBridge;
+  routerEventBridge;
   constructor(config) {
     this.config = config;
     this.localProvider = config.localModel;
     this.remoteProvider = config.remoteModel;
     const localLmscript = toLmscriptProvider(config.localModel, "local");
-    this.localRuntime = new LScriptRuntime({ provider: localLmscript });
+    const remoteLmscript = toLmscriptProvider(config.remoteModel, "remote");
+    this.middleware = new MiddlewareManager();
+    if (config.middleware) {
+      for (const hooks of config.middleware) {
+        this.middleware.use(hooks);
+      }
+    }
+    if (config.modelPricing) {
+      this.costTracker = new CostTracker();
+      this.modelPricing = config.modelPricing;
+    }
+    const localCache = config.triageCacheTtlMs ? new ExecutionCache(new MemoryCacheBackend()) : void 0;
+    this.localRuntime = new LScriptRuntime({
+      provider: localLmscript,
+      defaultTemperature: 0.1,
+      cache: localCache,
+      costTracker: this.costTracker
+    });
+    const remoteCache = config.cacheTtlMs ? new ExecutionCache(new MemoryCacheBackend()) : void 0;
+    const rateLimiter = config.rateLimit ? new RateLimiter(config.rateLimit) : void 0;
+    this.rateLimiter = rateLimiter;
+    this.budget = config.budget;
+    this.remoteRuntime = new LScriptRuntime({
+      provider: remoteLmscript,
+      middleware: this.middleware,
+      cache: remoteCache,
+      costTracker: this.costTracker,
+      budget: config.budget,
+      rateLimiter
+    });
     this.session = config.session ?? createEmptySession();
     this.systemPrompt = config.systemPrompt ?? "You are a helpful AI assistant with access to tools.";
     this.maxIterations = config.maxIterations ?? 10;
@@ -290,12 +1196,55 @@ var ObotoAgent = class _ObotoAgent {
       config.localModelName,
       config.maxContextTokens ?? 8192
     );
+    if (config.toolMiddleware) {
+      for (const mw of config.toolMiddleware) {
+        config.router.use(mw);
+      }
+    }
     this.routerTool = createRouterTool(config.router);
     this.triageFn = createTriageFunction(config.localModelName);
+    if (config.embeddingProvider) {
+      this.conversationRAG = new ConversationRAG(this.remoteRuntime, {
+        embeddingProvider: config.embeddingProvider,
+        vectorStore: config.vectorStore,
+        topK: config.ragTopK,
+        minScore: config.ragMinScore,
+        embeddingModel: config.ragEmbeddingModel,
+        autoIndex: config.ragAutoIndex,
+        indexToolResults: config.ragIndexToolResults,
+        formatContext: config.ragFormatContext
+      });
+    }
+    if (config.permissionPolicy) {
+      this.permissionGuard = new PermissionGuard(
+        config.permissionPolicy,
+        config.permissionPrompter ?? null,
+        this.bus
+      );
+    }
+    if (config.compactionConfig) {
+      this.sessionCompactor = new SessionCompactor(this.bus, config.compactionConfig);
+    }
+    if (config.hookRunner) {
+      this.hookIntegration = new HookIntegration(config.hookRunner, this.bus);
+    }
+    this.slashCommands = new SlashCommandRegistry(config.agentRuntime);
+    this.usageTracker = new AgentUsageTracker();
+    this.usageBridge = new UsageBridge(this.usageTracker, this.costTracker);
+    this.routerEventBridge = new RouterEventBridge(this.bus);
+    if (isLLMRouter(config.localModel)) {
+      this.routerEventBridge.attach(config.localModel, "local");
+    }
+    if (isLLMRouter(config.remoteModel)) {
+      this.routerEventBridge.attach(config.remoteModel, "remote");
+    }
     this.contextManager.push({
       role: "system",
       content: this.systemPrompt
     });
+    if (this.session.messages.length > 0) {
+      this.contextManager.pushAll(sessionToHistory(this.session));
+    }
   }
   // ── Public API ─────────────────────────────────────────────────────
   /** Subscribe to agent events. Returns an unsubscribe function. */
@@ -312,10 +1261,29 @@ var ObotoAgent = class _ObotoAgent {
       this.interrupt(text);
       return;
     }
+    const parsedCmd = this.slashCommands.parseCommand(text);
+    if (parsedCmd) {
+      const result = await this.slashCommands.executeCustomCommand(parsedCmd.name, parsedCmd.args);
+      if (result !== null) {
+        this.bus.emit("slash_command", {
+          command: parsedCmd.name,
+          args: parsedCmd.args,
+          result
+        });
+        return;
+      }
+    }
     this.isProcessing = true;
     this.interrupted = false;
     try {
       await this.executionLoop(text);
+      this.usageBridge.endTurn();
+      if (this.sessionCompactor) {
+        const result = this.sessionCompactor.compactIfNeeded(this.session);
+        if (result && result.removedMessageCount > 0) {
+          this.session = result.compactedSession;
+        }
+      }
     } catch (err) {
       this.bus.emit("error", {
         message: err instanceof Error ? err.message : String(err),
@@ -329,16 +1297,15 @@ var ObotoAgent = class _ObotoAgent {
    * Interrupt the current execution loop.
    * Optionally inject new directives into the context.
    */
-  interrupt(newDirectives) {
+  async interrupt(newDirectives) {
     this.interrupted = true;
     this.bus.emit("interruption", { newDirectives });
     if (newDirectives) {
       const msg = {
-        role: MessageRole2.User,
+        role: MessageRole4.User,
         blocks: [{ kind: "text", text: `[INTERRUPTION] ${newDirectives}` }]
       };
-      this.session.messages.push(msg);
-      this.contextManager.push(toChat(msg));
+      await this.recordMessage(msg);
       this.bus.emit("state_updated", { reason: "interruption" });
     }
   }
@@ -350,20 +1317,136 @@ var ObotoAgent = class _ObotoAgent {
   get processing() {
     return this.isProcessing;
   }
-  /** Remove all event listeners. */
+  /** Get cost tracking summary (if cost tracking is enabled). */
+  getCostSummary() {
+    if (!this.costTracker) return void 0;
+    const totalTokens = this.costTracker.getTotalTokens();
+    const totalCost = this.costTracker.getTotalCost(this.modelPricing);
+    const usageMap = this.costTracker.getUsageByFunction();
+    const byFunction = {};
+    for (const [fnName, entry] of usageMap) {
+      byFunction[fnName] = entry;
+    }
+    return { totalCost, totalTokens, byFunction };
+  }
+  /**
+   * Get unified cost summary combining both as-agent and lmscript tracking.
+   * Uses the UsageBridge to provide a single view of all token/cost data.
+   */
+  getUnifiedCostSummary(asPricing) {
+    return this.usageBridge.getCostSummary(this.modelPricing, asPricing);
+  }
+  /** Get the usage bridge for direct access to unified tracking. */
+  getUsageBridge() {
+    return this.usageBridge;
+  }
+  /** Remove all event listeners and detach router event subscriptions. */
   removeAllListeners() {
     this.bus.removeAllListeners();
+    this.routerEventBridge.detachAll();
+  }
+  /** Sync session and repopulate context manager (for reuse across turns). */
+  async syncSession(session) {
+    this.session = session;
+    this.contextManager.clear();
+    await this.contextManager.push({ role: "system", content: this.systemPrompt });
+    if (session.messages.length > 0) {
+      await this.contextManager.pushAll(sessionToHistory(session));
+    }
+  }
+  /** Update the streaming token callback between turns. */
+  setOnToken(callback) {
+    this.onToken = callback;
+  }
+  /** Get the ConversationRAG instance (if RAG is enabled). */
+  getConversationRAG() {
+    return this.conversationRAG;
+  }
+  /** Get the slash command registry. */
+  getSlashCommands() {
+    return this.slashCommands;
+  }
+  /** Get the as-agent usage tracker. */
+  getUsageTracker() {
+    return this.usageTracker;
+  }
+  /** Get the permission guard (if permissions are configured). */
+  getPermissionGuard() {
+    return this.permissionGuard;
+  }
+  /** Get the session compactor (if compaction is configured). */
+  getSessionCompactor() {
+    return this.sessionCompactor;
+  }
+  /** Get the router event bridge for observability into LLMRouter health. */
+  getRouterEventBridge() {
+    return this.routerEventBridge;
+  }
+  /**
+   * Manually compact the session. Returns null if compaction is not configured.
+   */
+  compactSession() {
+    if (!this.sessionCompactor) return null;
+    const result = this.sessionCompactor.compact(this.session);
+    if (result.removedMessageCount > 0) {
+      this.session = result.compactedSession;
+    }
+    return result;
+  }
+  /**
+   * Retrieve relevant past context for a query via the RAG pipeline.
+   * Returns undefined if RAG is not configured.
+   */
+  async retrieveContext(query) {
+    if (!this.conversationRAG) return void 0;
+    const { context } = await this.conversationRAG.retrieve(query);
+    return context || void 0;
   }
   // ── Internal ───────────────────────────────────────────────────────
+  /**
+   * Record a message in the session, context manager, and optionally RAG index.
+   * Centralizes message recording to ensure RAG indexing stays in sync.
+   */
+  async recordMessage(msg) {
+    this.session.messages.push(msg);
+    await this.contextManager.push(toChat(msg));
+    if (this.conversationRAG) {
+      this.conversationRAG.indexMessage(msg, this.session.messages.length - 1).catch((err) => {
+        console.warn("[ObotoAgent] RAG indexing failed:", err instanceof Error ? err.message : err);
+      });
+    }
+  }
+  /**
+   * Record a tool execution result in the RAG index.
+   */
+  recordToolResult(command, kwargs, result) {
+    if (this.conversationRAG) {
+      this.conversationRAG.indexToolResult(command, kwargs, result).catch((err) => {
+        console.warn("[ObotoAgent] RAG tool indexing failed:", err instanceof Error ? err.message : err);
+      });
+    }
+  }
   async executionLoop(userInput) {
     this.bus.emit("user_input", { text: userInput });
     const userMsg = {
-      role: MessageRole2.User,
+      role: MessageRole4.User,
       blocks: [{ kind: "text", text: userInput }]
     };
-    this.session.messages.push(userMsg);
-    await this.contextManager.push(toChat(userMsg));
+    await this.recordMessage(userMsg);
     this.bus.emit("state_updated", { reason: "user_input" });
+    if (this.conversationRAG) {
+      try {
+        const { context } = await this.conversationRAG.retrieve(userInput);
+        if (context) {
+          await this.contextManager.push({
+            role: "system",
+            content: context
+          });
+        }
+      } catch (err) {
+        console.warn("[ObotoAgent] RAG retrieval failed:", err instanceof Error ? err.message : err);
+      }
+    }
     const triageResult = await this.triage(userInput);
     this.bus.emit("triage_result", triageResult);
     if (this.interrupted) return;
@@ -371,17 +1454,14 @@ var ObotoAgent = class _ObotoAgent {
       const response = triageResult.directResponse;
       this.bus.emit("agent_thought", { text: response, model: "local" });
       const assistantMsg = {
-        role: MessageRole2.Assistant,
+        role: MessageRole4.Assistant,
         blocks: [{ kind: "text", text: response }]
       };
-      this.session.messages.push(assistantMsg);
-      await this.contextManager.push(toChat(assistantMsg));
+      await this.recordMessage(assistantMsg);
       this.bus.emit("state_updated", { reason: "assistant_response" });
       this.bus.emit("turn_complete", { model: "local", escalated: false });
       return;
     }
-    const provider = triageResult.escalate ? this.remoteProvider : this.localProvider;
-    const modelName = triageResult.escalate ? this.config.remoteModelName : this.config.localModelName;
     if (triageResult.escalate) {
       this.bus.emit("agent_thought", {
         text: triageResult.reasoning,
@@ -389,7 +1469,14 @@ var ObotoAgent = class _ObotoAgent {
         escalating: true
       });
     }
-    await this.executeWithModel(provider, modelName, userInput);
+    const modelName = triageResult.escalate ? this.config.remoteModelName : this.config.localModelName;
+    const runtime = triageResult.escalate ? this.remoteRuntime : this.localRuntime;
+    console.log("[ObotoAgent] Executing with model:", modelName, "| via lmscript AgentLoop");
+    if (this.onToken) {
+      await this.executeWithStreaming(runtime, modelName, userInput);
+    } else {
+      await this.executeWithAgentLoop(runtime, modelName, userInput);
+    }
   }
   async triage(userInput) {
     const recentMessages = this.contextManager.getMessages().slice(-5);
@@ -404,16 +1491,95 @@ var ObotoAgent = class _ObotoAgent {
     });
     return result.data;
   }
-  /** Maximum characters per tool result before truncation. */
-  static MAX_TOOL_RESULT_CHARS = 8e3;
-  /** Maximum times the same tool+args can repeat before forcing a text response. */
-  static MAX_DUPLICATE_CALLS = 2;
   /**
-   * Execute the agent loop using llm-wrapper directly.
-   * When onToken is configured, uses streaming for real-time token output.
-   * No JSON mode, no schema enforcement — just natural chat with tool calling.
+   * Execute using lmscript's AgentLoop for iterative tool calling.
+   * This replaces the old custom tool loop with lmscript's battle-tested implementation.
+   *
+   * Benefits:
+   * - Schema validation on final output
+   * - Budget checking via CostTracker
+   * - Rate limiting via RateLimiter
+   * - Middleware lifecycle hooks
+   * - Automatic retry with backoff
+   */
+  async executeWithAgentLoop(runtime, modelName, userInput) {
+    const { z: z5 } = await import("zod");
+    const agentFn = {
+      name: "agent-task",
+      model: modelName,
+      system: this.systemPrompt,
+      prompt: (input) => {
+        const contextMessages = this.contextManager.getMessages();
+        const contextStr = contextMessages.filter((m) => m.role !== "system").map((m) => {
+          const text = typeof m.content === "string" ? m.content : "[complex content]";
+          return `${m.role}: ${text}`;
+        }).join("\n");
+        return contextStr ? `${contextStr}
+
+user: ${input}` : input;
+      },
+      schema: z5.object({
+        response: z5.string().describe("The assistant's response to the user"),
+        reasoning: z5.string().optional().describe("Internal reasoning about the approach taken")
+      }),
+      tools: [this.routerTool],
+      temperature: 0.7,
+      maxRetries: 1
+    };
+    const agentConfig = {
+      maxIterations: this.maxIterations,
+      onToolCall: (tc) => {
+        const command = typeof tc.arguments === "object" && tc.arguments !== null ? tc.arguments.command ?? tc.name : tc.name;
+        const kwargs = typeof tc.arguments === "object" && tc.arguments !== null ? tc.arguments.kwargs ?? {} : {};
+        this.bus.emit("tool_execution_complete", {
+          command,
+          kwargs,
+          result: typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result)
+        });
+        const resultStr = typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result);
+        this.recordToolResult(String(command), kwargs, resultStr);
+      },
+      onIteration: (iteration, response) => {
+        this.bus.emit("agent_thought", {
+          text: response,
+          model: modelName,
+          iteration
+        });
+        if (this.interrupted) return false;
+      }
+    };
+    const agentLoop = new AgentLoop(runtime, agentConfig);
+    const result = await agentLoop.run(agentFn, userInput);
+    const responseText = result.data.response;
+    const assistantMsg = {
+      role: MessageRole4.Assistant,
+      blocks: [{ kind: "text", text: responseText }]
+    };
+    await this.recordMessage(assistantMsg);
+    this.bus.emit("state_updated", { reason: "assistant_response" });
+    this.bus.emit("turn_complete", {
+      model: modelName,
+      escalated: true,
+      iterations: result.iterations,
+      toolCalls: result.toolCalls.length,
+      usage: result.usage
+    });
+  }
+  /**
+   * Execute with streaming token emission.
+   * Uses the raw llm-wrapper provider for streaming, combined with
+   * manual tool calling (since streaming + structured agent loops are complex).
+   *
+   * This preserves real-time token delivery while still leveraging
+   * the lmscript infrastructure:
+   * - Rate limiting (acquire/reportTokens per call)
+   * - Cost tracking (trackUsage per call)
+   * - Budget checking (checkBudget before each call)
+   * - Middleware lifecycle hooks (onBeforeExecute/onComplete per turn)
    */
-  async executeWithModel(provider, modelName, _userInput) {
+  async executeWithStreaming(_runtime, modelName, _userInput) {
+    const { zodToJsonSchema } = await import("zod-to-json-schema");
+    const provider = modelName === this.config.remoteModelName ? this.remoteProvider : this.localProvider;
     const contextMessages = this.contextManager.getMessages();
     const messages = contextMessages.map((m) => ({
       role: m.role,
@@ -433,129 +1599,205 @@ var ObotoAgent = class _ObotoAgent {
     ];
     let totalToolCalls = 0;
     const callHistory = [];
-    const useStreaming = !!this.onToken;
-    for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
-      if (this.interrupted) break;
-      const isLastIteration = iteration === this.maxIterations;
-      if (isLastIteration) {
-        messages.push({
-          role: "user",
-          content: "You have used all available tool iterations. Please provide your final response now based on what you have gathered so far. Do not call any more tools."
-        });
-      }
-      const params = {
-        model: modelName,
-        messages: [...messages],
-        temperature: 0.7,
-        ...isLastIteration ? {} : { tools, tool_choice: "auto" }
-      };
-      let response;
-      if (useStreaming) {
-        response = await this.streamAndAggregate(provider, params);
-      } else {
-        response = await provider.chat(params);
-      }
-      const choice = response.choices[0];
-      const content = choice?.message?.content ?? "";
-      const toolCalls = choice?.message?.tool_calls;
-      if (content) {
-        this.bus.emit("agent_thought", {
-          text: content,
-          model: modelName,
-          iteration
-        });
-      }
-      if (!toolCalls || toolCalls.length === 0) {
-        const assistantMsg = {
-          role: MessageRole2.Assistant,
-          blocks: [{ kind: "text", text: content }]
-        };
-        this.session.messages.push(assistantMsg);
-        await this.contextManager.push(toChat(assistantMsg));
-        this.bus.emit("state_updated", { reason: "assistant_response" });
-        this.bus.emit("turn_complete", {
-          model: modelName,
-          escalated: true,
-          iterations: iteration,
-          toolCalls: totalToolCalls
-        });
-        return;
-      }
-      messages.push({
-        role: "assistant",
-        content: content || null,
-        tool_calls: toolCalls
-      });
-      const toolResults = [];
-      for (const tc of toolCalls) {
+    const turnStartTime = Date.now();
+    const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    const syntheticCtx = {
+      fn: { name: "streaming-turn", model: modelName, system: this.systemPrompt, prompt: () => "", schema: {} },
+      input: _userInput,
+      messages,
+      attempt: 1,
+      startTime: turnStartTime
+    };
+    await this.middleware.runBeforeExecute(syntheticCtx);
+    try {
+      for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
         if (this.interrupted) break;
-        let args;
-        try {
-          args = JSON.parse(tc.function.arguments);
-        } catch {
-          args = {};
+        if (this.costTracker && this.budget) {
+          this.costTracker.checkBudget(this.budget);
         }
-        const command = args.command ?? tc.function.name;
-        const kwargs = args.kwargs ?? {};
-        const callSig = JSON.stringify({ command, kwargs });
-        const dupeCount = callHistory.filter((s) => s === callSig).length;
-        callHistory.push(callSig);
-        if (dupeCount >= _ObotoAgent.MAX_DUPLICATE_CALLS) {
+        await this.rateLimiter?.acquire();
+        const isLastIteration = iteration === this.maxIterations;
+        if (isLastIteration) {
           messages.push({
-            role: "tool",
-            tool_call_id: tc.id,
-            content: `You already called "${command}" with these arguments ${dupeCount} time(s) and received the result. Do not repeat this call. Use the data you already have to proceed.`
-          });
-          this.bus.emit("tool_execution_complete", {
-            command,
-            kwargs,
-            result: "[duplicate call blocked]"
+            role: "user",
+            content: "You have used all available tool iterations. Please provide your final response now based on what you have gathered so far. Do not call any more tools."
           });
-          toolResults.push({ command, success: false });
-          totalToolCalls++;
-          continue;
         }
-        this.bus.emit("tool_execution_start", { command, kwargs });
-        let result;
-        let success = true;
+        const params = {
+          model: modelName,
+          messages: [...messages],
+          temperature: 0.7,
+          ...isLastIteration ? {} : { tools, tool_choice: "auto" }
+        };
+        let response;
         try {
-          result = await tool.execute(args);
+          response = await this.streamAndAggregate(provider, params);
         } catch (err) {
-          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-          success = false;
+          await this.middleware.runError(
+            syntheticCtx,
+            err instanceof Error ? err : new Error(String(err))
+          );
+          console.error("[ObotoAgent] LLM call failed:", err instanceof Error ? err.message : err);
+          throw err;
+        }
+        const usage = response?.usage;
+        if (usage) {
+          const promptTokens = usage.prompt_tokens ?? 0;
+          const completionTokens = usage.completion_tokens ?? 0;
+          const usageTotal = usage.total_tokens ?? promptTokens + completionTokens;
+          totalUsage.promptTokens += promptTokens;
+          totalUsage.completionTokens += completionTokens;
+          totalUsage.totalTokens += usageTotal;
+          this.rateLimiter?.reportTokens(usageTotal);
+          this.usageBridge.recordFromLmscript(modelName, {
+            promptTokens,
+            completionTokens,
+            totalTokens: usageTotal
+          });
+          if (this.costTracker) {
+            this.bus.emit("cost_update", {
+              iteration,
+              totalTokens: this.costTracker.getTotalTokens(),
+              totalCost: this.costTracker.getTotalCost(this.modelPricing)
+            });
+          }
+        }
+        const choice = response?.choices?.[0];
+        const content = choice?.message?.content ?? "";
+        const toolCalls = choice?.message?.tool_calls;
+        if (content) {
+          this.bus.emit("agent_thought", {
+            text: content,
+            model: modelName,
+            iteration
+          });
+        }
+        if (!toolCalls || toolCalls.length === 0) {
+          const assistantMsg = {
+            role: MessageRole4.Assistant,
+            blocks: [{ kind: "text", text: content }]
+          };
+          await this.recordMessage(assistantMsg);
+          this.bus.emit("state_updated", { reason: "assistant_response" });
+          this.bus.emit("turn_complete", {
+            model: modelName,
+            escalated: true,
+            iterations: iteration,
+            toolCalls: totalToolCalls,
+            usage: totalUsage
+          });
+          await this.middleware.runComplete(syntheticCtx, {
+            data: content,
+            raw: content,
+            usage: totalUsage
+          });
+          return;
         }
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-        const truncated = resultStr.length > _ObotoAgent.MAX_TOOL_RESULT_CHARS ? resultStr.slice(0, _ObotoAgent.MAX_TOOL_RESULT_CHARS) + `
-
-[... truncated ${resultStr.length - _ObotoAgent.MAX_TOOL_RESULT_CHARS} characters. Use the data above to proceed.]` : resultStr;
-        this.bus.emit("tool_execution_complete", { command, kwargs, result: truncated });
-        toolResults.push({ command, success });
-        totalToolCalls++;
         messages.push({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: truncated
+          role: "assistant",
+          content: content || null,
+          tool_calls: toolCalls
         });
+        for (const tc of toolCalls) {
+          if (this.interrupted) break;
+          let args;
+          try {
+            args = JSON.parse(tc.function.arguments);
+          } catch {
+            args = {};
+          }
+          const command = args.command ?? tc.function.name;
+          const kwargs = args.kwargs ?? {};
+          const toolInputStr = JSON.stringify({ command, kwargs });
+          if (this.permissionGuard) {
+            const outcome = this.permissionGuard.checkPermission(command, toolInputStr);
+            if (outcome.kind === "deny") {
+              messages.push({
+                role: "tool",
+                tool_call_id: tc.id,
+                content: `Permission denied for tool "${command}": ${outcome.reason ?? "denied by policy"}`
+              });
+              totalToolCalls++;
+              continue;
+            }
+          }
+          if (this.hookIntegration) {
+            const hookResult = this.hookIntegration.runPreToolUse(command, toolInputStr);
+            if (hookResult.denied) {
+              messages.push({
+                role: "tool",
+                tool_call_id: tc.id,
+                content: `Tool "${command}" blocked by pre-use hook: ${hookResult.messages.join("; ")}`
+              });
+              totalToolCalls++;
+              continue;
+            }
+          }
+          const callSig = JSON.stringify({ command, kwargs });
+          const dupeCount = callHistory.filter((s) => s === callSig).length;
+          callHistory.push(callSig);
+          if (dupeCount >= 2) {
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: `You already called "${command}" with these arguments ${dupeCount} time(s). Use the data you already have.`
+            });
+            totalToolCalls++;
+            continue;
+          }
+          this.bus.emit("tool_execution_start", { command, kwargs });
+          let result;
+          let isError = false;
+          try {
+            result = await tool.execute(args);
+          } catch (err) {
+            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+            isError = true;
+          }
+          const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+          const truncated = resultStr.length > 8e3 ? resultStr.slice(0, 8e3) + `
+
+[... truncated ${resultStr.length - 8e3} characters.]` : resultStr;
+          if (this.hookIntegration) {
+            this.hookIntegration.runPostToolUse(command, toolInputStr, truncated, isError);
+          }
+          this.bus.emit("tool_execution_complete", { command, kwargs, result: truncated });
+          this.recordToolResult(command, kwargs, truncated);
+          totalToolCalls++;
+          messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            content: truncated
+          });
+        }
       }
-      this.bus.emit("tool_round_complete", {
-        iteration,
-        tools: toolResults,
-        totalToolCalls
+      const fallbackMsg = {
+        role: MessageRole4.Assistant,
+        blocks: [{ kind: "text", text: "I reached the maximum number of iterations. Here is what I have so far." }]
+      };
+      await this.recordMessage(fallbackMsg);
+      this.bus.emit("state_updated", { reason: "max_iterations" });
+      this.bus.emit("turn_complete", {
+        model: modelName,
+        escalated: true,
+        iterations: this.maxIterations,
+        toolCalls: totalToolCalls,
+        usage: totalUsage
       });
+      await this.middleware.runComplete(syntheticCtx, {
+        data: "max_iterations_reached",
+        raw: "",
+        usage: totalUsage
+      });
+    } catch (err) {
+      if (!(err instanceof Error && err.message.includes("LLM call failed"))) {
+        await this.middleware.runError(
+          syntheticCtx,
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+      throw err;
     }
-    const fallbackMsg = {
-      role: MessageRole2.Assistant,
-      blocks: [{ kind: "text", text: "I reached the maximum number of iterations. Here is what I have so far." }]
-    };
-    this.session.messages.push(fallbackMsg);
-    await this.contextManager.push(toChat(fallbackMsg));
-    this.bus.emit("state_updated", { reason: "max_iterations" });
-    this.bus.emit("turn_complete", {
-      model: modelName,
-      escalated: true,
-      iterations: this.maxIterations,
-      toolCalls: totalToolCalls
-    });
   }
   /**
    * Stream an LLM call, emitting tokens in real-time, then aggregate into
@@ -578,15 +1820,316 @@ var ObotoAgent = class _ObotoAgent {
     return aggregateStream(replay());
   }
 };
+
+// src/adapters/tool-extensions.ts
+import {
+  DynamicBranchNode,
+  LeafNode,
+  TreeBuilder,
+  createMemoryModule
+} from "@sschepis/swiss-army-tool";
+var AgentDynamicTools = class extends DynamicBranchNode {
+  provider;
+  constructor(config) {
+    super({
+      name: config.name,
+      description: config.description,
+      ttlMs: config.ttlMs ?? 6e4
+    });
+    this.provider = config.provider;
+  }
+  async refresh() {
+    const entries = await this.provider.discover();
+    for (const entry of entries) {
+      this.addChild(
+        new LeafNode({
+          name: entry.name,
+          description: entry.description,
+          requiredArgs: entry.requiredArgs,
+          optionalArgs: entry.optionalArgs,
+          handler: entry.handler
+        }),
+        { overwrite: true }
+      );
+    }
+  }
+  /** Manually register a tool entry without waiting for refresh. */
+  registerTool(entry) {
+    this.addChild(
+      new LeafNode({
+        name: entry.name,
+        description: entry.description,
+        requiredArgs: entry.requiredArgs,
+        optionalArgs: entry.optionalArgs,
+        handler: entry.handler
+      }),
+      { overwrite: true }
+    );
+  }
+  /** Remove a dynamically registered tool by name. */
+  unregisterTool(name) {
+    return this.removeChild(name);
+  }
+};
+function createToolTimingMiddleware(bus) {
+  return async (ctx, next) => {
+    const startTime = Date.now();
+    bus.emit("tool_execution_start", {
+      command: ctx.command,
+      kwargs: ctx.kwargs,
+      resolvedPath: ctx.resolvedPath
+    });
+    try {
+      const result = await next();
+      const durationMs = Date.now() - startTime;
+      bus.emit("tool_execution_complete", {
+        command: ctx.command,
+        kwargs: ctx.kwargs,
+        result: result.length > 500 ? result.slice(0, 500) + "..." : result,
+        durationMs
+      });
+      return result;
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      bus.emit("error", {
+        message: `Tool execution failed: ${ctx.command}`,
+        error: err,
+        durationMs
+      });
+      throw err;
+    }
+  };
+}
+function createToolTimeoutMiddleware(maxMs) {
+  return async (_ctx, next) => {
+    const result = await Promise.race([
+      next(),
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`Tool execution timed out after ${maxMs}ms`)),
+          maxMs
+        )
+      )
+    ]);
+    return result;
+  };
+}
+function createToolAuditMiddleware(session) {
+  let callIndex = 0;
+  return async (ctx, next) => {
+    const idx = ++callIndex;
+    const startTime = Date.now();
+    const result = await next();
+    const durationMs = Date.now() - startTime;
+    const entry = JSON.stringify({
+      command: ctx.command,
+      kwargs: ctx.kwargs,
+      resultLength: result.length,
+      durationMs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    session.kvStore.set(`_audit:${idx}`, entry);
+    return result;
+  };
+}
+function createAgentToolTree(config) {
+  const builder = TreeBuilder.create("root", "Agent command tree with integrated tools");
+  if (config.includeMemory !== false) {
+    const memoryBranch = createMemoryModule(config.session);
+    builder.addBranch(memoryBranch);
+  }
+  const root = builder.build();
+  if (config.dynamicProviders) {
+    for (const dp of config.dynamicProviders) {
+      const dynamicBranch = new AgentDynamicTools({
+        name: dp.name,
+        description: dp.description,
+        provider: dp.provider,
+        ttlMs: dp.ttlMs
+      });
+      root.addChild(dynamicBranch);
+    }
+  }
+  if (config.staticBranches) {
+    for (const branch of config.staticBranches) {
+      root.addChild(branch);
+    }
+  }
+  return root;
+}
+
+// src/adapters/pipeline-workflows.ts
+import { z as z4 } from "zod";
+import {
+  Pipeline
+} from "@sschepis/lmscript";
+var TriagePipelineSchema = z4.object({
+  intent: z4.string().describe("The classified intent of the user input"),
+  complexity: z4.enum(["simple", "moderate", "complex"]).describe("Estimated task complexity"),
+  requiresTools: z4.boolean().describe("Whether tools are needed"),
+  suggestedApproach: z4.string().describe("Brief approach suggestion"),
+  escalate: z4.boolean().describe("Whether to escalate to the remote model")
+});
+var PlanSchema = z4.object({
+  steps: z4.array(z4.object({
+    description: z4.string(),
+    toolRequired: z4.string().optional(),
+    expectedOutput: z4.string().optional()
+  })).describe("Ordered list of steps to accomplish the task"),
+  estimatedComplexity: z4.enum(["low", "medium", "high"]),
+  reasoning: z4.string().describe("Why this plan was chosen")
+});
+var ExecutionSchema = z4.object({
+  response: z4.string().describe("The response or result of executing the plan"),
+  stepsCompleted: z4.number().describe("Number of plan steps completed"),
+  toolsUsed: z4.array(z4.string()).optional(),
+  confidence: z4.enum(["low", "medium", "high"])
+});
+var SummarySchema2 = z4.object({
+  summary: z4.string().describe("Concise summary of what was accomplished"),
+  keyPoints: z4.array(z4.string()).describe("Key points from the execution"),
+  followUpSuggestions: z4.array(z4.string()).optional()
+});
+function createTriageStep(modelName, systemPrompt) {
+  return {
+    name: "pipeline-triage",
+    model: modelName,
+    system: systemPrompt ?? "You are a task classifier. Analyze the input and determine its intent, complexity, and whether it requires tools or escalation.",
+    prompt: (input) => `Classify this request:
+
+${input}`,
+    schema: TriagePipelineSchema,
+    temperature: 0.1,
+    maxRetries: 1
+  };
+}
+function createPlanStep(modelName, systemPrompt) {
+  return {
+    name: "pipeline-plan",
+    model: modelName,
+    system: systemPrompt ?? "You are a task planner. Given the triage analysis, create a step-by-step plan to accomplish the task.",
+    prompt: (triage) => `Create an execution plan based on this analysis:
+Intent: ${triage.intent}
+Complexity: ${triage.complexity}
+Requires tools: ${triage.requiresTools}
+Suggested approach: ${triage.suggestedApproach}`,
+    schema: PlanSchema,
+    temperature: 0.3,
+    maxRetries: 1
+  };
+}
+function createExecutionStep(modelName, tools, systemPrompt) {
+  return {
+    name: "pipeline-execute",
+    model: modelName,
+    system: systemPrompt ?? "You are a task executor. Follow the given plan step by step and produce the result.",
+    prompt: (plan) => {
+      const stepsStr = plan.steps.map((s, i) => `${i + 1}. ${s.description}${s.toolRequired ? ` (tool: ${s.toolRequired})` : ""}`).join("\n");
+      return `Execute this plan:
+
+${stepsStr}
+
+Reasoning: ${plan.reasoning}`;
+    },
+    schema: ExecutionSchema,
+    tools,
+    temperature: 0.5,
+    maxRetries: 1
+  };
+}
+function createSummaryStep(modelName, systemPrompt) {
+  return {
+    name: "pipeline-summarize",
+    model: modelName,
+    system: systemPrompt ?? "You are a summarizer. Condense the execution results into a clear, concise summary.",
+    prompt: (execution) => `Summarize these results:
+Response: ${execution.response}
+Steps completed: ${execution.stepsCompleted}
+Confidence: ${execution.confidence}
+` + (execution.toolsUsed?.length ? `Tools used: ${execution.toolsUsed.join(", ")}` : ""),
+    schema: SummarySchema2,
+    temperature: 0.3,
+    maxRetries: 1
+  };
+}
+function createTriagePlanExecutePipeline(modelName, tools) {
+  return Pipeline.from(createTriageStep(modelName)).pipe(createPlanStep(modelName)).pipe(createExecutionStep(modelName, tools));
+}
+function createFullPipeline(modelName, tools) {
+  return Pipeline.from(createTriageStep(modelName)).pipe(createPlanStep(modelName)).pipe(createExecutionStep(modelName, tools)).pipe(createSummaryStep(modelName));
+}
+function createAnalyzeRespondPipeline(modelName) {
+  const analyzeStep = {
+    name: "pipeline-analyze",
+    model: modelName,
+    system: "You are an analyst. Understand the request and identify the best approach.",
+    prompt: (input) => `Analyze this request:
+
+${input}`,
+    schema: TriagePipelineSchema,
+    temperature: 0.1,
+    maxRetries: 1
+  };
+  const respondStep = {
+    name: "pipeline-respond",
+    model: modelName,
+    system: "You are a helpful assistant. Based on the analysis, provide a comprehensive response.",
+    prompt: (analysis) => `Respond to this request:
+Intent: ${analysis.intent}
+Approach: ${analysis.suggestedApproach}`,
+    schema: ExecutionSchema,
+    temperature: 0.7,
+    maxRetries: 1
+  };
+  return Pipeline.from(analyzeStep).pipe(respondStep);
+}
+async function runAgentPipeline(pipeline, input, config) {
+  const result = await pipeline.execute(config.runtime, input);
+  if (config.onStepComplete) {
+    for (const step of result.steps) {
+      config.onStepComplete(step.name, step.data, step.usage);
+    }
+  }
+  return result;
+}
 export {
+  AgentDynamicTools,
   AgentEventBus,
+  AgentUsageTracker,
   ContextManager,
+  ConversationRAG,
+  ExecutionSchema,
+  HookIntegration,
   ObotoAgent,
+  PermissionGuard,
+  PlanSchema,
+  RouterEventBridge,
+  SessionCompactor,
+  SlashCommandRegistry,
+  SummarySchema2 as SummarySchema,
+  TriagePipelineSchema,
   TriageSchema,
+  UsageBridge,
+  asTokenUsageToLmscript,
+  createAgentToolTree,
+  createAnalyzeRespondPipeline,
   createEmptySession,
+  createExecutionStep,
+  createFullPipeline,
+  createPlanStep,
   createRouterTool,
+  createSummaryStep,
+  createToolAuditMiddleware,
+  createToolTimeoutMiddleware,
+  createToolTimingMiddleware,
   createTriageFunction,
+  createTriagePlanExecutePipeline,
+  createTriageStep,
+  estimateCostFromAsAgent,
   fromChat,
+  isLLMRouter,
+  lmscriptToAsTokenUsage,
+  runAgentPipeline,
   sessionToHistory,
   toChat,
   toLmscriptProvider