@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/modules/agent/runtime/server/Session.js

@@ -0,0 +1,1010 @@
+import { z } from "zod";
+import { buildSystemPrompt, buildSystemPromptEntries } from "./agentPrompt.js";
+import { provider, models } from "#blokkli-build/agent-server";
+import {
+  send,
+  KEEP_RECENT_TURNS,
+  resolveSkills,
+  transformText,
+  classifyError,
+  pruneMessages,
+  pruneForPersistence,
+  computeStateHash,
+  verifyStateHash,
+  validateMessages
+} from "./helpers.js";
+import { buildDefinition, stripSchemaOverhead } from "./server-tools/index.js";
+import loadSkillTool from "./server-tools/load_skills/index.js";
+import loadToolsTool from "./server-tools/load_tools/index.js";
+import createPlanTool from "./server-tools/create_plan/index.js";
+import completePlanStepTool from "./server-tools/complete_plan_step/index.js";
+const serverTools = [
+  loadSkillTool,
+  loadToolsTool,
+  createPlanTool,
+  completePlanStepTool
+];
+export class Session {
+  messages = [];
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  abortController = null;
+  isProcessing = false;
+  /** Names of eager tools sent to the LLM on every turn */
+  toolNames = [];
+  /** Names of lazy tools held back until activated via load_tools */
+  lazyToolNames = [];
+  /** Names of lazy tools that have been activated via load_tools */
+  activatedLazyTools = /* @__PURE__ */ new Set();
+  /** Names of skills that have been loaded via load_skills */
+  loadedSkills = /* @__PURE__ */ new Set();
+  /** Page context received from client on init */
+  pageContext;
+  /** Current plan (null when no plan is active) */
+  plan = null;
+  /** Whether any real work (non-server tool calls) happened since the last plan step started */
+  planStepHasWork = false;
+  /** Pending plan approval promise resolver */
+  pendingPlanApproval = null;
+  /** Pre-pruned messages snapshot for transcript (captured before pruneMessages) */
+  unprunedMessages = [];
+  /** Last generic tool definitions for transcript */
+  lastTools = [];
+  /** Last raw request payload for transcript (dev only) */
+  lastDebugPayload = null;
+  /** Bundled tool metadata map for server-side resolution */
+  bundledToolMap;
+  /** Cache for resolved JSON Schemas (Zod→JSON Schema is deterministic) */
+  jsonSchemaCache = /* @__PURE__ */ new Map();
+  constructor(toolDefinitions) {
+    this.bundledToolMap = new Map(toolDefinitions.map((t) => [t.name, t]));
+  }
+  /**
+   * Resolve a single tool name into a ClientToolDefinition.
+   * Resolves from bundled metadata. Caches the JSON Schema conversion.
+   */
+  resolveToolDefinition(name) {
+    const bundled = this.bundledToolMap.get(name);
+    if (!bundled) return void 0;
+    let inputSchema = this.jsonSchemaCache.get(name);
+    if (!inputSchema) {
+      inputSchema = stripSchemaOverhead(
+        z.toJSONSchema(bundled.paramsSchema)
+      );
+      this.jsonSchemaCache.set(name, inputSchema);
+    }
+    return {
+      name: bundled.name,
+      description: bundled.description,
+      input_schema: inputSchema,
+      ...bundled.lazy ? { lazy: true } : {},
+      category: bundled.category,
+      ...bundled.volatile ? { volatile: true } : {}
+    };
+  }
+  /**
+   * Resolve multiple tool names into ClientToolDefinition objects.
+   * Skips names that cannot be resolved.
+   */
+  resolveToolDefinitions(names) {
+    const result = [];
+    for (const name of names) {
+      const def = this.resolveToolDefinition(name);
+      if (def) {
+        result.push(def);
+      }
+    }
+    return result;
+  }
+  /**
+   * Look up name + description for a tool.
+   */
+  getToolSummary(name) {
+    const bundled = this.bundledToolMap.get(name);
+    if (!bundled) return void 0;
+    return { name: bundled.name, description: bundled.description };
+  }
+  // --------------------------------------------------------------------------
+  // Public methods
+  // --------------------------------------------------------------------------
+  init(toolNames, pageContext) {
+    this.toolNames = [];
+    this.lazyToolNames = [];
+    for (const name of toolNames) {
+      const bundled = this.bundledToolMap.get(name);
+      const isLazy = bundled?.lazy ?? false;
+      if (isLazy) {
+        this.lazyToolNames.push(name);
+      } else {
+        this.toolNames.push(name);
+      }
+    }
+    this.activatedLazyTools = /* @__PURE__ */ new Set();
+    this.loadedSkills = /* @__PURE__ */ new Set();
+    this.pageContext = pageContext;
+  }
+  start(peer, prompt, apiKey, authSecret, selectedUuids, autoLoadTools, autoLoadSkills, preSeededResults, autoExecuteTools) {
+    if (this.isProcessing) {
+      send(peer, {
+        type: "error",
+        errorType: "bad_request",
+        message: "Agent is already processing a request"
+      });
+      return;
+    }
+    this.runAgentLoop(
+      peer,
+      prompt,
+      apiKey,
+      authSecret,
+      selectedUuids,
+      autoLoadTools,
+      autoLoadSkills,
+      preSeededResults,
+      autoExecuteTools
+    );
+  }
+  resolveToolResult(callId, result) {
+    const pending = this.pendingToolCalls.get(callId);
+    if (pending) {
+      pending.resolve(result);
+    }
+  }
+  cancel(peer) {
+    this.abortController?.abort();
+    for (const pending of this.pendingToolCalls.values()) {
+      pending.reject(new Error("Cancelled"));
+    }
+    this.pendingToolCalls.clear();
+    if (this.pendingPlanApproval) {
+      this.pendingPlanApproval.resolve(false);
+      this.pendingPlanApproval = null;
+    }
+    send(peer, { type: "done" });
+  }
+  acceptChanges(peer, authSecret) {
+    this.safePushUserMessage(`[System: Changes accepted and applied.]`);
+    send(peer, { type: "done", message: "Changes accepted" });
+    this.sendConversationState(peer, authSecret);
+  }
+  rejectChanges(peer, authSecret) {
+    this.safePushUserMessage(
+      `[System: Changes rejected. All pending changes have been reverted. The page is back to its previous state.]`
+    );
+    send(peer, { type: "done", message: "Changes rejected" });
+    this.sendConversationState(peer, authSecret);
+  }
+  approvePlan() {
+    if (this.pendingPlanApproval) {
+      this.pendingPlanApproval.resolve(true);
+      this.pendingPlanApproval = null;
+    }
+  }
+  rejectPlan() {
+    if (this.pendingPlanApproval) {
+      this.pendingPlanApproval.resolve(false);
+      this.pendingPlanApproval = null;
+    }
+  }
+  getTranscript(peer) {
+    send(peer, {
+      type: "transcript",
+      transcript: this.buildTranscript()
+    });
+  }
+  newConversation(peer, authSecret) {
+    this.abortController?.abort();
+    this.messages = [];
+    this.unprunedMessages = [];
+    this.lastTools = [];
+    this.lastDebugPayload = null;
+    this.activatedLazyTools.clear();
+    this.loadedSkills.clear();
+    this.plan = null;
+    if (this.pendingPlanApproval) {
+      this.pendingPlanApproval.resolve(false);
+      this.pendingPlanApproval = null;
+    }
+    send(peer, { type: "done" });
+    this.sendConversationState(peer, authSecret);
+  }
+  cleanup() {
+    this.abortController?.abort();
+    for (const pending of this.pendingToolCalls.values()) {
+      pending.reject(new Error("Session closed"));
+    }
+    this.pendingToolCalls.clear();
+    if (this.pendingPlanApproval) {
+      this.pendingPlanApproval.resolve(false);
+      this.pendingPlanApproval = null;
+    }
+    this.plan = null;
+    this.messages = [];
+    this.toolNames = [];
+    this.lazyToolNames = [];
+    this.activatedLazyTools.clear();
+    this.loadedSkills.clear();
+    this.pageContext = void 0;
+  }
+  /**
+   * Build a persistence snapshot and send it to the client.
+   */
+  sendConversationState(peer, authSecret) {
+    const state = this.getConversationStateForPersistence(authSecret);
+    send(peer, { type: "conversation_state", state });
+  }
+  /**
+   * Create an aggressively pruned snapshot of the current conversation
+   * for client-side persistence.
+   */
+  getConversationStateForPersistence(authSecret) {
+    const prunedMessages = pruneForPersistence(this.messages);
+    const activatedLazyTools = Array.from(this.activatedLazyTools);
+    const hash = computeStateHash(
+      prunedMessages,
+      activatedLazyTools,
+      authSecret
+    );
+    return {
+      messages: prunedMessages,
+      activatedLazyTools,
+      hash
+    };
+  }
+  /**
+   * Restore conversation state from a client-provided snapshot.
+   * Verifies HMAC integrity before loading.
+   */
+  restoreConversation(state, authSecret) {
+    if (!verifyStateHash(state, authSecret)) {
+      return { success: false, reason: "Invalid state hash" };
+    }
+    const issues = validateMessages(state.messages);
+    if (issues.length > 0) {
+      return { success: false, reason: "Invalid message structure" };
+    }
+    this.messages = state.messages;
+    this.unprunedMessages = [];
+    this.lastTools = [];
+    const validLazyToolNames = new Set(this.lazyToolNames);
+    this.activatedLazyTools = new Set(
+      state.activatedLazyTools.filter((name) => validLazyToolNames.has(name))
+    );
+    this.plan = null;
+    return { success: true };
+  }
+  // --------------------------------------------------------------------------
+  // Private methods
+  // --------------------------------------------------------------------------
+  /**
+   * Convert the server plan to a client-facing plan (strips descriptions).
+   */
+  toClientPlan() {
+    if (!this.plan) return null;
+    return {
+      title: this.plan.title,
+      steps: this.plan.steps.map(
+        (s) => ({
+          label: s.label,
+          status: s.status
+        })
+      )
+    };
+  }
+  /**
+   * Build an ActivePlanContext from the current plan state,
+   * or undefined if no plan step is in progress.
+   */
+  getActivePlanContext() {
+    const currentStep = this.plan?.steps.find((s) => s.status === "in_progress");
+    if (!this.plan || !currentStep) return void 0;
+    return {
+      title: this.plan.title,
+      totalSteps: this.plan.steps.length,
+      completedSteps: this.plan.steps.filter((s) => s.status === "completed").length,
+      currentStep: {
+        label: currentStep.label,
+        description: currentStep.description
+      },
+      remainingSteps: this.plan.steps.filter((s) => s.status === "pending").map((s) => s.label)
+    };
+  }
+  /**
+   * Wait for the user to approve or reject the plan.
+   */
+  waitForPlanApproval() {
+    return new Promise((resolve) => {
+      this.pendingPlanApproval = { resolve };
+    });
+  }
+  async runAgentLoop(peer, prompt, apiKey, authSecret, selectedUuids, autoLoadTools, autoLoadSkills, preSeededResults, autoExecuteTools) {
+    if (this.toolNames.length === 0) {
+      send(peer, {
+        type: "error",
+        errorType: "bad_request",
+        message: "No tools available. Client must send init message with tools first."
+      });
+      return;
+    }
+    if (!this.pageContext) {
+      send(peer, {
+        type: "error",
+        errorType: "bad_request",
+        message: "No page context available. Client must send init message with pageContext first."
+      });
+      return;
+    }
+    const resolvedSkills = resolveSkills(this.pageContext);
+    if (autoLoadTools?.length) {
+      for (const name of autoLoadTools) {
+        if (this.lazyToolNames.includes(name) && !this.activatedLazyTools.has(name)) {
+          this.activatedLazyTools.add(name);
+        }
+      }
+    }
+    const autoLoadedSkillBlocks = [];
+    if (autoLoadSkills?.length) {
+      for (const skillName of autoLoadSkills) {
+        const skill = resolvedSkills.find((s) => s.name === skillName);
+        if (!skill || this.loadedSkills.has(skill.name)) continue;
+        this.loadedSkills.add(skill.name);
+        for (const toolName of skill.tools) {
+          if (this.lazyToolNames.includes(toolName) && !this.activatedLazyTools.has(toolName)) {
+            this.activatedLazyTools.add(toolName);
+          }
+        }
+        autoLoadedSkillBlocks.push({
+          type: "skill",
+          name: skill.name,
+          text: `# Skill: ${skill.name}
+
+${skill.content}`
+        });
+      }
+    }
+    const userParts = [];
+    if (selectedUuids?.length) {
+      userParts.push(
+        `[User has selected the following paragraphs: ${selectedUuids.join(", ")}]`
+      );
+    }
+    userParts.push(prompt);
+    const userMessage = autoLoadedSkillBlocks.length > 0 ? {
+      role: "user",
+      content: [
+        ...autoLoadedSkillBlocks,
+        { type: "text", text: userParts.join("\n\n") }
+      ]
+    } : { role: "user", content: userParts.join("\n\n") };
+    this.messages.push(userMessage);
+    if (preSeededResults?.length) {
+      for (let i = 0; i < preSeededResults.length; i++) {
+        const preSeeded = preSeededResults[i];
+        const toolUseId = `preseed_${i}`;
+        this.messages.push({
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              id: toolUseId,
+              name: preSeeded.toolName,
+              input: preSeeded.params
+            }
+          ]
+        });
+        this.messages.push({
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: toolUseId,
+              content: JSON.stringify(preSeeded.result)
+            }
+          ]
+        });
+      }
+    }
+    let allAutoToolsSkipLlm = false;
+    if (autoExecuteTools?.length) {
+      let hasErrors = false;
+      let allSkip = true;
+      for (let i = 0; i < autoExecuteTools.length; i++) {
+        const autoTool = autoExecuteTools[i];
+        const callId = `auto_${i}`;
+        const toolUseId = `auto_tu_${i}`;
+        send(peer, {
+          type: "tool_call",
+          callId,
+          tool: autoTool.toolName,
+          params: autoTool.params
+        });
+        try {
+          const clientResult = await this.waitForToolResult(callId);
+          this.messages.push({
+            role: "assistant",
+            content: [
+              {
+                type: "tool_use",
+                id: toolUseId,
+                name: autoTool.toolName,
+                input: autoTool.params
+              }
+            ]
+          });
+          if (clientResult.error) {
+            hasErrors = true;
+            allSkip = false;
+            this.messages.push({
+              role: "user",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: toolUseId,
+                  content: JSON.stringify({ error: clientResult.error }),
+                  is_error: true
+                }
+              ]
+            });
+          } else {
+            if (!clientResult.skipLlmResponse) {
+              allSkip = false;
+            }
+            let resultForLLM = clientResult.result;
+            if (typeof resultForLLM === "object" && resultForLLM !== null && "agentMessage" in resultForLLM) {
+              const { agentMessage, ...rest } = resultForLLM;
+              resultForLLM = { ...rest, label: agentMessage };
+            }
+            this.messages.push({
+              role: "user",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: toolUseId,
+                  content: JSON.stringify(resultForLLM)
+                }
+              ]
+            });
+          }
+        } catch {
+          hasErrors = true;
+          allSkip = false;
+          this.messages.push({
+            role: "assistant",
+            content: [
+              {
+                type: "tool_use",
+                id: toolUseId,
+                name: autoTool.toolName,
+                input: autoTool.params
+              }
+            ]
+          });
+          this.messages.push({
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: toolUseId,
+                content: JSON.stringify({
+                  error: "Auto-executed tool call was cancelled."
+                }),
+                is_error: true
+              }
+            ]
+          });
+        }
+      }
+      allAutoToolsSkipLlm = allSkip && !hasErrors;
+    }
+    if (allAutoToolsSkipLlm) {
+      send(peer, { type: "done" });
+      this.sendConversationState(peer, authSecret);
+      this.isProcessing = false;
+      return;
+    }
+    this.abortController = new AbortController();
+    this.isProcessing = true;
+    let toolCallCounter = 0;
+    let planRetryCount = 0;
+    let streamRetryCount = 0;
+    const MAX_STREAM_RETRIES = 1;
+    let lastToolCallKey = "";
+    let consecutiveIdenticalCalls = 0;
+    const MAX_IDENTICAL_CALLS = 2;
+    try {
+      while (true) {
+        if (this.abortController.signal.aborted) {
+          break;
+        }
+        send(peer, { type: "thinking" });
+        const assistantContent = [];
+        const toolResults = [];
+        const extraBlocks = [];
+        let messagesCommittedByPlanTool = false;
+        let currentToolUse = null;
+        let currentTextContent = "";
+        let inTextBlock = false;
+        const eagerTools = this.resolveToolDefinitions(this.toolNames);
+        const activatedToolNames = this.lazyToolNames.filter(
+          (name) => this.activatedLazyTools.has(name)
+        );
+        const activatedTools = this.resolveToolDefinitions(activatedToolNames);
+        const unloadedLazyToolNames = this.lazyToolNames.filter(
+          (name) => !this.activatedLazyTools.has(name)
+        );
+        const unloadedLazyTools = unloadedLazyToolNames.map((name) => this.getToolSummary(name)).filter(
+          (s) => s !== void 0
+        );
+        const defCtx = {
+          resolvedSkills,
+          plan: this.plan,
+          unloadedLazyTools
+        };
+        const serverToolDefs = serverTools.map((t) => buildDefinition(t, defCtx)).filter((d) => d !== null);
+        const allTools = [...serverToolDefs, ...eagerTools, ...activatedTools];
+        this.lastTools = allTools;
+        const lazyToolSummaries = this.lazyToolNames.filter((name) => !this.activatedLazyTools.has(name)).map((name) => this.getToolSummary(name)).filter(
+          (s) => s !== void 0
+        );
+        const systemPrompt = buildSystemPrompt(
+          this.pageContext,
+          resolvedSkills,
+          lazyToolSummaries,
+          this.getActivePlanContext(),
+          this.loadedSkills
+        );
+        const stream = provider.createStream(
+          {
+            apiKey,
+            model: (models.find((m) => m.isDefault) || models[0]).name
+          },
+          {
+            systemPrompt,
+            messages: this.messages,
+            tools: allTools,
+            maxTokens: 4096,
+            signal: this.abortController.signal
+          }
+        );
+        try {
+          for await (const event of stream) {
+            if (this.abortController?.signal.aborted) {
+              break;
+            }
+            switch (event.type) {
+              case "debug_request":
+                this.lastDebugPayload = event.payload;
+                break;
+              case "text_start":
+                inTextBlock = true;
+                currentTextContent = "";
+                break;
+              case "text_delta":
+                if (inTextBlock) {
+                  const transformed = transformText(event.text);
+                  currentTextContent += transformed;
+                  send(peer, { type: "text_delta", content: transformed });
+                }
+                break;
+              case "text_end":
+                if (inTextBlock && currentTextContent) {
+                  assistantContent.push({
+                    type: "text",
+                    text: currentTextContent
+                  });
+                }
+                currentTextContent = "";
+                inTextBlock = false;
+                break;
+              case "tool_use_start":
+                currentToolUse = {
+                  id: event.id,
+                  name: event.name,
+                  inputJson: ""
+                };
+                break;
+              case "tool_use_delta":
+                if (currentToolUse) {
+                  currentToolUse.inputJson += event.partial_json;
+                }
+                break;
+              case "tool_use_end":
+                if (currentToolUse) {
+                  let input;
+                  try {
+                    input = JSON.parse(currentToolUse.inputJson || "{}");
+                  } catch {
+                    input = {};
+                    assistantContent.push({
+                      type: "tool_use",
+                      id: currentToolUse.id,
+                      name: currentToolUse.name,
+                      input
+                    });
+                    toolResults.push({
+                      type: "tool_result",
+                      tool_use_id: currentToolUse.id,
+                      content: JSON.stringify({
+                        error: "Your tool call produced malformed JSON input. Please try again."
+                      }),
+                      is_error: true
+                    });
+                    currentToolUse = null;
+                    break;
+                  }
+                  const callId = `tc_${toolCallCounter++}`;
+                  assistantContent.push({
+                    type: "tool_use",
+                    id: currentToolUse.id,
+                    name: currentToolUse.name,
+                    input
+                  });
+                  const toolCallKey = currentToolUse.name + ":" + currentToolUse.inputJson;
+                  if (toolCallKey === lastToolCallKey) {
+                    consecutiveIdenticalCalls++;
+                  } else {
+                    lastToolCallKey = toolCallKey;
+                    consecutiveIdenticalCalls = 1;
+                  }
+                  if (consecutiveIdenticalCalls > MAX_IDENTICAL_CALLS) {
+                    toolResults.push({
+                      type: "tool_result",
+                      tool_use_id: currentToolUse.id,
+                      content: JSON.stringify({
+                        error: `You have called "${currentToolUse.name}" ${consecutiveIdenticalCalls} times in a row with identical parameters and received the same result each time. Stop repeating this call. Use the information you already have or try a different approach.`
+                      }),
+                      is_error: true
+                    });
+                    currentToolUse = null;
+                    break;
+                  }
+                  const matchedServerTool = serverTools.find(
+                    (t) => t.name === currentToolUse.name
+                  );
+                  if (matchedServerTool) {
+                    if (matchedServerTool.isAvailable && !matchedServerTool.isAvailable(defCtx)) {
+                      toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: currentToolUse.id,
+                        content: JSON.stringify({
+                          error: "This tool is not available right now."
+                        }),
+                        is_error: true
+                      });
+                      currentToolUse = null;
+                      break;
+                    }
+                    const handlerCtx = {
+                      toolUseId: currentToolUse.id,
+                      send: (msg) => send(peer, msg),
+                      resolvedSkills,
+                      lazyToolNames: this.lazyToolNames,
+                      activatedLazyTools: this.activatedLazyTools,
+                      loadedSkills: this.loadedSkills,
+                      plan: this.plan,
+                      setPlan: (p) => {
+                        this.plan = p;
+                      },
+                      toClientPlan: () => this.toClientPlan(),
+                      waitForPlanApproval: () => this.waitForPlanApproval(),
+                      assistantContent,
+                      commitMessagesEarly: (toolResult) => {
+                        if (assistantContent.length) {
+                          this.messages.push({
+                            role: "assistant",
+                            content: [...assistantContent]
+                          });
+                          assistantContent.length = 0;
+                        }
+                        this.messages.push({
+                          role: "user",
+                          content: [toolResult]
+                        });
+                      },
+                      updateLastToolResult: (toolUseId, content) => {
+                        const lastMsg = this.messages[this.messages.length - 1];
+                        if (lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
+                          const resultBlock = lastMsg.content.find(
+                            (b) => b.type === "tool_result" && b.tool_use_id === toolUseId
+                          );
+                          if (resultBlock && resultBlock.type === "tool_result") {
+                            resultBlock.content = content;
+                          }
+                        }
+                      },
+                      planStepHasWork: this.planStepHasWork,
+                      markPlanStepWork: () => {
+                        this.planStepHasWork = true;
+                      },
+                      resetPlanStepWork: () => {
+                        this.planStepHasWork = false;
+                      }
+                    };
+                    try {
+                      const coercedInput = {};
+                      for (const key of Object.keys(input)) {
+                        const value = input[key];
+                        if (typeof value === "string" && (value[0] === "[" || value[0] === "{")) {
+                          try {
+                            coercedInput[key] = JSON.parse(value);
+                          } catch {
+                            coercedInput[key] = value;
+                          }
+                        } else {
+                          coercedInput[key] = value;
+                        }
+                      }
+                      const parsed = matchedServerTool.inputSchema(defCtx).parse(coercedInput);
+                      const result = await matchedServerTool.handle(
+                        handlerCtx,
+                        parsed
+                      );
+                      toolResults.push(...result.toolResults);
+                      if (result.extraBlocks) {
+                        extraBlocks.push(...result.extraBlocks);
+                      }
+                      if (result.messagesCommitted) {
+                        messagesCommittedByPlanTool = true;
+                      }
+                    } catch (e) {
+                      toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: currentToolUse.id,
+                        content: JSON.stringify({
+                          error: `Invalid input: ${e.message}`
+                        }),
+                        is_error: true
+                      });
+                    }
+                    currentToolUse = null;
+                    break;
+                  }
+                  send(peer, {
+                    type: "tool_call",
+                    callId,
+                    tool: currentToolUse.name,
+                    params: input
+                  });
+                  try {
+                    const clientResult = await this.waitForToolResult(callId);
+                    if (clientResult.error) {
+                      toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: currentToolUse.id,
+                        content: JSON.stringify({
+                          error: clientResult.error
+                        }),
+                        is_error: true
+                      });
+                    } else {
+                      let resultForLLM = clientResult.result;
+                      if (typeof resultForLLM === "object" && resultForLLM !== null && "agentMessage" in resultForLLM) {
+                        const { agentMessage, ...rest } = resultForLLM;
+                        resultForLLM = { ...rest, label: agentMessage };
+                      }
+                      toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: currentToolUse.id,
+                        content: JSON.stringify(resultForLLM)
+                      });
+                      this.planStepHasWork = true;
+                    }
+                  } catch (error) {
+                    toolResults.push({
+                      type: "tool_result",
+                      tool_use_id: currentToolUse.id,
+                      content: JSON.stringify({
+                        error: error.message
+                      }),
+                      is_error: true
+                    });
+                  }
+                  currentToolUse = null;
+                }
+                break;
+              case "reasoning_summary":
+                assistantContent.push({
+                  type: "reasoning",
+                  id: event.id,
+                  text: event.text,
+                  encryptedContent: event.encryptedContent
+                });
+                break;
+              case "message_end":
+                if (event.inputTokens !== void 0 && event.outputTokens !== void 0) {
+                  const defaultModel = models.find((m) => m.isDefault) || models[0];
+                  send(peer, {
+                    type: "usage",
+                    usage: {
+                      inputTokens: event.inputTokens,
+                      outputTokens: event.outputTokens,
+                      cacheCreationInputTokens: event.cacheCreationInputTokens ?? 0,
+                      cacheReadInputTokens: event.cacheReadInputTokens ?? 0,
+                      pricing: defaultModel?.pricing ?? null
+                    }
+                  });
+                }
+                break;
+              case "error":
+                throw event.error;
+            }
+          }
+        } catch (streamError) {
+          const isApiError = typeof streamError.status === "number";
+          const isRetryable = !isApiError && toolResults.length === 0;
+          if (isRetryable && streamRetryCount < MAX_STREAM_RETRIES) {
+            streamRetryCount++;
+            console.warn(
+              `[blokkli agent] Transient stream error, retrying (attempt ${streamRetryCount}/${MAX_STREAM_RETRIES}):`,
+              streamError
+            );
+            continue;
+          }
+          if (isRetryable && this.messages[this.messages.length - 1] === userMessage) {
+            this.messages.pop();
+            console.error(
+              "[blokkli agent] Transient stream error, retries exhausted:",
+              streamError
+            );
+            const classified = classifyError(streamError);
+            send(peer, { type: "error", ...classified, retryable: true });
+            break;
+          }
+          throw streamError;
+        }
+        if (this.abortController?.signal.aborted) {
+          break;
+        }
+        if (messagesCommittedByPlanTool) {
+          this.planStepHasWork = false;
+          continue;
+        }
+        if (assistantContent.length) {
+          this.messages.push({
+            role: "assistant",
+            content: assistantContent
+          });
+        }
+        if (toolResults.length) {
+          this.messages.push({
+            role: "user",
+            content: [...toolResults, ...extraBlocks]
+          });
+          planRetryCount = 0;
+          streamRetryCount = 0;
+        }
+        if (toolResults.length === 0) {
+          const hasActivePlan = this.plan && this.plan.steps.some((s) => s.status === "in_progress");
+          if (hasActivePlan && planRetryCount < 2) {
+            planRetryCount++;
+            this.safePushUserMessage("[Continue with the plan.]");
+            continue;
+          }
+          const finalMessage = assistantContent.filter(
+            (c) => c.type === "text"
+          ).map((t) => t.text).join("\n").trim();
+          send(peer, { type: "done", message: finalMessage || void 0 });
+          break;
+        }
+      }
+    } catch (error) {
+      if (error.name !== "AbortError" && !this.abortController?.signal.aborted) {
+        console.error("Agent loop error:", error);
+        const classified = classifyError(error);
+        send(peer, { type: "error", ...classified });
+      }
+    } finally {
+      this.isProcessing = false;
+      this.abortController = null;
+      this.unprunedMessages = structuredClone(this.messages);
+      pruneMessages(
+        this.messages,
+        KEEP_RECENT_TURNS,
+        this.buildToolMetadataMap()
+      );
+      if (this.loadedSkills.size > 0) {
+        this.reconcileLoadedSkills();
+      }
+      this.sendConversationState(peer, authSecret);
+    }
+  }
+  waitForToolResult(callId) {
+    return new Promise((resolve, reject) => {
+      this.pendingToolCalls.set(callId, {
+        resolve: (result) => {
+          this.pendingToolCalls.delete(callId);
+          resolve(result);
+        },
+        reject: (error) => {
+          this.pendingToolCalls.delete(callId);
+          reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Bug 3 fix: safely push a user message, merging with the last message
+   * if it's also a user message to avoid consecutive same-role messages.
+   */
+  safePushUserMessage(text) {
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage && lastMessage.role === "user") {
+      if (typeof lastMessage.content === "string") {
+        lastMessage.content = lastMessage.content + "\n" + text;
+      } else {
+        lastMessage.content.push({ type: "text", text });
+      }
+    } else {
+      this.messages.push({ role: "user", content: text });
+    }
+  }
+  /**
+   * Remove skills from loadedSkills whose text content has been pruned
+   * from the conversation messages.
+   */
+  reconcileLoadedSkills() {
+    const presentSkills = /* @__PURE__ */ new Set();
+    for (const msg of this.messages) {
+      if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (block.type === "skill") {
+          presentSkills.add(block.name);
+        }
+      }
+    }
+    for (const name of this.loadedSkills) {
+      if (!presentSkills.has(name)) {
+        this.loadedSkills.delete(name);
+      }
+    }
+  }
+  /**
+   * Build a map of tool name to pruning metadata from all known tools.
+   */
+  buildToolMetadataMap() {
+    const map = /* @__PURE__ */ new Map();
+    for (const name of [...this.toolNames, ...this.lazyToolNames]) {
+      const bundled = this.bundledToolMap.get(name);
+      if (bundled?.volatile) {
+        map.set(name, { volatile: true });
+      }
+    }
+    return map;
+  }
+  buildTranscript() {
+    const system = this.pageContext ? buildSystemPromptEntries(
+      this.pageContext,
+      resolveSkills(this.pageContext),
+      this.lazyToolNames.map((name) => this.getToolSummary(name)).filter(
+        (s) => s !== void 0
+      ),
+      this.getActivePlanContext(),
+      this.loadedSkills
+    ) : [];
+    const messages = this.messages.map((msg, i) => {
+      const entry = {
+        type: msg.role === "assistant" ? "agent" : "user",
+        seen: msg.content
+      };
+      const unpruned = this.unprunedMessages[i];
+      if (unpruned) {
+        const seenJson = JSON.stringify(msg.content);
+        const fullJson = JSON.stringify(unpruned.content);
+        if (seenJson !== fullJson) {
+          entry.full = unpruned.content;
+        }
+      }
+      return entry;
+    });
+    const tools = this.lastTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+    return {
+      system,
+      messages,
+      tools,
+      ...this.lastDebugPayload ? { lastRequest: this.lastDebugPayload } : {}
+    };
+  }
+}