@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

package/dist/modules/agent/runtime/server/classes/ConversationMessage/index.js

@@ -0,0 +1,156 @@
+import { ToolResult } from "../../../shared/toolResult.js";
+export class ConversationMessage {
+  /**
+   * Rehydrate a message from its wire form (persistence restore). Tool names on
+   * relay results are NOT resolved here (a single message lacks the preceding
+   * assistant); `ConversationHistory.replaceAll` resolves them.
+   */
+  static fromWire(msg) {
+    if (msg.role === "assistant") {
+      return new AssistantMessage(msg.content);
+    }
+    if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
+      return ToolRelayMessage.fromWire(msg);
+    }
+    return new UserPromptMessage(msg.content);
+  }
+}
+export class UserPromptMessage extends ConversationMessage {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  kind = "userPrompt";
+  toWire() {
+    return { role: "user", content: this.content };
+  }
+  /** Pure: a copy with `text` merged in (string concat or appended text block). */
+  appendText(text) {
+    if (typeof this.content === "string") {
+      return new UserPromptMessage(this.content + "\n" + text);
+    }
+    return new UserPromptMessage([...this.content, { type: "text", text }]);
+  }
+}
+export class AssistantMessage extends ConversationMessage {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  kind = "assistant";
+  toWire() {
+    return { role: "assistant", content: this.content };
+  }
+  /** Map of `tool_use` id → tool name, for resolving relay tool names. */
+  toolUseNames() {
+    const map = /* @__PURE__ */ new Map();
+    if (Array.isArray(this.content)) {
+      for (const block of this.content) {
+        if (block.type === "tool_use") map.set(block.id, block.name);
+      }
+    }
+    return map;
+  }
+  /**
+   * Pure: a copy with every `tool_use` input collapsed to `{ _pruned: true }`.
+   * `text` / `reasoning` / `skill` blocks are left untouched.
+   */
+  withPrunedToolUseInputs() {
+    if (!Array.isArray(this.content)) return this;
+    const blocks = this.content.map(
+      (block) => block.type === "tool_use" ? { ...block, input: { _pruned: true } } : block
+    );
+    return new AssistantMessage(blocks);
+  }
+}
+export class ToolRelayMessage extends ConversationMessage {
+  constructor(results, auxBlocks = []) {
+    super();
+    this.results = results;
+    this.auxBlocks = auxBlocks;
+  }
+  kind = "toolRelay";
+  static fromWire(msg) {
+    const content = Array.isArray(msg.content) ? msg.content : [];
+    const results = [];
+    const auxBlocks = [];
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        results.push({
+          toolUseId: block.tool_use_id,
+          toolName: void 0,
+          result: ToolResult.fromWire(block.content, block.is_error)
+        });
+      } else if (block.type === "text" || block.type === "skill") {
+        auxBlocks.push(block);
+      }
+    }
+    return new ToolRelayMessage(results, auxBlocks);
+  }
+  get entries() {
+    return this.results;
+  }
+  toWire() {
+    const content = this.results.map((entry) => {
+      const block = {
+        type: "tool_result",
+        tool_use_id: entry.toolUseId,
+        content: entry.result.toWire()
+      };
+      if (entry.result.isErrorResult()) block.is_error = true;
+      return block;
+    });
+    return { role: "user", content: [...content, ...this.auxBlocks] };
+  }
+  /** Estimated token cost of the full (uncompressed) tool-result content. */
+  estimatedTokens() {
+    return this.results.reduce((sum, e) => sum + e.result.estimatedTokens(), 0);
+  }
+  /**
+   * Estimated tokens once the given results are marked stale — used by the
+   * budget walk so a large stale result doesn't consume budget (the
+   * volatile/staleness decision logically precedes the size ceiling).
+   */
+  projectedTokens(staleToolUseIds) {
+    return this.results.reduce((sum, e) => {
+      const r = staleToolUseIds.has(e.toolUseId) ? e.result.stale() : e.result;
+      return sum + r.estimatedTokens();
+    }, 0);
+  }
+  /** Pure: a copy with an auxiliary text/skill block appended. */
+  appendAux(block) {
+    return new ToolRelayMessage(this.results, [...this.auxBlocks, block]);
+  }
+  /**
+   * Pure projection: per-result, stale results (by tool_use id) collapse to
+   * `{ stale }`, otherwise compress the body when `compressBody`. Aux blocks are
+   * dropped when `stripAux`.
+   */
+  project(opts) {
+    const results = this.results.map((entry) => {
+      let result = entry.result;
+      if (opts.staleToolUseIds.has(entry.toolUseId)) {
+        result = result.stale();
+      } else if (opts.compressBody) {
+        result = result.compressed();
+      }
+      return result === entry.result ? entry : { ...entry, result };
+    });
+    return new ToolRelayMessage(results, opts.stripAux ? [] : this.auxBlocks);
+  }
+  /** Pure: a copy with one result replaced (create_plan post-approval swap). */
+  replaceResult(toolUseId, result) {
+    const results = this.results.map(
+      (entry) => entry.toolUseId === toolUseId ? { ...entry, result } : entry
+    );
+    return new ToolRelayMessage(results, this.auxBlocks);
+  }
+  /** Pure: a copy with tool names resolved via the given lookup (rehydration). */
+  withResolvedNames(resolve) {
+    const results = this.results.map((entry) => ({
+      ...entry,
+      toolName: entry.toolName ?? resolve(entry.toolUseId)
+    }));
+    return new ToolRelayMessage(results, this.auxBlocks);
+  }
+}

package/dist/modules/agent/runtime/server/{Session.d.ts → classes/Session/index.d.ts}

@@ -1,8 +1,9 @@
 import type { Peer } from 'crossws';
-import type { PageContext, ClientToolDefinition, ServerToolMetadata, ConversationStateSnapshot, GenericMessage } from '../shared/types.js';
-import type { ServerPlan } from './server-tools/index.js';
+import type { PageContext, ClientToolDefinition, ServerToolMetadata, ConversationStateSnapshot } from '../../../shared/types.js';
+import type { ServerPlan } from '../../server-tools/index.js';
 export declare class Session {
-    messages: GenericMessage[];
+    /** The single, immutable source of truth for the conversation. */
+    private history;
     pendingToolCalls: Map<string, {
         resolve: (result: {
             result: unknown;
@@ -31,8 +32,6 @@ export declare class Session {
     pendingPlanApproval: {
         resolve: (approved: boolean) => void;
     } | null;
-    /** Pre-pruned messages snapshot for transcript (captured before pruneMessages) */
-    private unprunedMessages;
     /** Last generic tool definitions for transcript */
     private lastTools;
     /** Last raw request payload for transcript (dev only) */
@@ -64,7 +63,13 @@ export declare class Session {
     }[], autoExecuteTools?: {
         toolName: string;
         params: Record<string, unknown>;
-    }[]): void;
+    }[], rollbackToUserMessageIndex?: number): void;
+    /**
+     * Remove the Nth real user turn (0-based) and every message after it.
+     * "Real user turn" excludes tool-result relays. Throws if the index is
+     * out of range — typically because the target turn has been pruned away.
+     */
+    private truncateAtUserMessage;
     resolveToolResult(callId: string, result: {
         result: unknown;
         error?: string;
@@ -111,18 +116,45 @@ export declare class Session {
     private runAgentLoop;
     private waitForToolResult;
     /**
-     * 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.
+     * Build the context object passed to a server-side tool handler. `assistantContent`
+     * is the live block array for the current turn — `commitMessagesEarly` flushes and
+     * resets it in place, so it must be the same reference the stream loop appends to.
      */
-    private safePushUserMessage;
+    private buildServerToolContext;
+    /**
+     * Dispatch a server-side tool: reject if unavailable, coerce + validate input,
+     * run the handler. Returns the blocks to merge into the turn's results.
+     */
+    private dispatchServerTool;
+    /**
+     * Dispatch a client-side tool: send the call to the peer and await its result.
+     * An `agentMessage` on the result replaces the `label` in the payload fed back
+     * to the LLM (the label is UI-only). Returns the tool_result block(s).
+     */
+    /**
+     * Validate an LLM-generated client tool call against its Zod `paramsSchema`
+     * (the same schema the client parses with), server-side, before dispatching
+     * to the peer. Returns an error string on a schema failure so the caller can
+     * reject it silently. Unknown tools pass through (handled by normal dispatch).
+     */
+    private validateClientToolInput;
+    private dispatchClientTool;
     /**
-     * Remove skills from loadedSkills whose text content has been pruned
-     * from the conversation messages.
+     * Append a synthetic assistant `tool_use` + user `tool_result` message pair —
+     * the shape used to inject pre-seeded results and to record auto-executed tool
+     * calls before the LLM loop starts.
      */
-    private reconcileLoadedSkills;
+    private pushToolExchange;
+    /**
+     * Safely push a user message, merging with the last message if it's also a
+     * user message — the LLM API rejects consecutive same-role messages.
+     */
+    private safePushUserMessage;
     /**
-     * Build a map of tool name to pruning metadata from all known tools.
+     * Whether a tool's results go stale after a mutation — used by the live
+     * projection's eager volatile eviction. Volatility is a property of the tool
+     * definition, so it holds regardless of the current tool set.
      */
-    private buildToolMetadataMap;
+    private volatileLookup;
     private buildTranscript;
 }