@blade-hq/agent-kit 1.0.27 → 1.0.28

package/dist/{chunk-SBASG3M2.js → chunk-UWNQ4PXK.js}

@@ -2,8 +2,9 @@ import {
   tapBridgeEvent
 } from "./chunk-J3XVFPOV.js";
 import {
-  BladeClient
-} from "./chunk-34GDDOWY.js";
+  BladeClient,
+  ClientProjectionBuilder
+} from "./chunk-YJ6BX3FU.js";
 import {
   createClientActions,
   useCardStateStore
@@ -618,1104 +619,6 @@ function isUiMeta(value) {
   return true;
 }
 
-// src/react/projection/helpers.ts
-function upsertToolCall(state, toolCallId, toolName, displayName, args) {
-  if (!toolCallId) return;
-  let found = false;
-  for (let i = 0; i < state.toolCalls.length; i++) {
-    if (state.toolCalls[i].id !== toolCallId) continue;
-    const tc = state.toolCalls[i];
-    state.toolCalls[i] = {
-      ...tc,
-      tool_name: toolName || tc.tool_name,
-      display_name: displayName || tc.display_name,
-      arguments: args || tc.arguments
-    };
-    found = true;
-    break;
-  }
-  if (!found) {
-    state.toolCalls.push({
-      id: toolCallId,
-      tool_name: toolName,
-      display_name: displayName,
-      arguments: args,
-      status: "pending"
-    });
-  }
-  let blockFound = false;
-  for (let i = 0; i < state.blocks.length; i++) {
-    const b = state.blocks[i];
-    if (b.type !== "tool_use" || b.tool_call_id !== toolCallId) continue;
-    state.blocks[i] = {
-      ...b,
-      content: args || b.content,
-      tool_name: toolName || b.tool_name,
-      display_name: displayName || b.display_name
-    };
-    blockFound = true;
-    break;
-  }
-  if (!blockFound) {
-    state.blocks.push({
-      type: "tool_use",
-      content: args,
-      tool_call_id: toolCallId,
-      tool_name: toolName || null,
-      display_name: displayName || null
-    });
-  }
-}
-function applyToolResult(state, toolCallId, result, status, durationMs, sourceLoop) {
-  let toolName = "";
-  let displayName = "";
-  let finalResult = result;
-  for (let i = 0; i < state.toolCalls.length; i++) {
-    const tc = state.toolCalls[i];
-    if (tc.id !== toolCallId) continue;
-    if (typeof result === "string") {
-      finalResult = maybeEnrichAskUserResult(tc.tool_name, result, sourceLoop);
-    }
-    const update = { status, result: finalResult };
-    if (durationMs != null) update.duration_ms = durationMs;
-    state.toolCalls[i] = { ...tc, ...update };
-    toolName = tc.tool_name;
-    displayName = tc.display_name;
-    break;
-  }
-  upsertToolResultBlock(state, toolCallId, finalResult, toolName, displayName);
-}
-function appendToolResultDelta(state, toolCallId, delta) {
-  if (!toolCallId || !delta) return;
-  let toolName = "";
-  let displayName = "";
-  let currentResult = "";
-  for (let i = 0; i < state.toolCalls.length; i++) {
-    const tc = state.toolCalls[i];
-    if (tc.id !== toolCallId) continue;
-    toolName = tc.tool_name;
-    displayName = tc.display_name;
-    if (typeof tc.result === "string") currentResult = tc.result;
-    state.toolCalls[i] = { ...tc, result: currentResult + delta };
-    break;
-  }
-  for (const block of state.blocks) {
-    if (block.type !== "tool_result" || block.tool_call_id !== toolCallId) continue;
-    if (typeof block.content === "string") currentResult = block.content;
-    break;
-  }
-  upsertToolResultBlock(state, toolCallId, currentResult + delta, toolName, displayName);
-}
-function upsertToolResultBlock(state, toolCallId, content, toolName, displayName) {
-  for (let i = 0; i < state.blocks.length; i++) {
-    const block = state.blocks[i];
-    if (block.type !== "tool_result" || block.tool_call_id !== toolCallId) continue;
-    state.blocks[i] = {
-      ...block,
-      content,
-      tool_name: toolName || block.tool_name,
-      display_name: displayName || block.display_name
-    };
-    return;
-  }
-  state.blocks.push({
-    type: "tool_result",
-    content,
-    tool_call_id: toolCallId,
-    tool_name: toolName || null,
-    display_name: displayName || null
-  });
-}
-function appendTextBlock(state, blockType, content) {
-  if (content == null || content === "") return;
-  const text = String(content);
-  const lastBlock = state.blocks[state.blocks.length - 1];
-  if (lastBlock && lastBlock.type === blockType && typeof lastBlock.content === "string") {
-    state.blocks[state.blocks.length - 1] = {
-      ...lastBlock,
-      content: lastBlock.content + text
-    };
-    return;
-  }
-  state.blocks.push({ type: blockType, content: text });
-}
-function appendToolCallArguments(state, toolCallId, delta) {
-  let newArgs = "";
-  for (let i = 0; i < state.toolCalls.length; i++) {
-    const tc = state.toolCalls[i];
-    if (tc.id === toolCallId) {
-      newArgs = tc.arguments + delta;
-      state.toolCalls[i] = { ...tc, arguments: newArgs };
-      break;
-    }
-  }
-  if (!newArgs) return;
-  for (let i = 0; i < state.blocks.length; i++) {
-    const b = state.blocks[i];
-    if (b.type === "tool_use" && b.tool_call_id === toolCallId) {
-      state.blocks[i] = { ...b, content: newArgs };
-      break;
-    }
-  }
-}
-function maybeEnrichAskUserResult(toolName, result, sourceLoop) {
-  if (!sourceLoop) return result;
-  const normalized = toolName.includes(":") ? toolName.split(":").pop() : toolName;
-  if (normalized !== "AskUserQuestion") return result;
-  try {
-    const payload = JSON.parse(result);
-    if (typeof payload !== "object" || payload === null) return result;
-    payload.source_loop = sourceLoop;
-    return JSON.stringify(payload);
-  } catch {
-    return result;
-  }
-}
-function buildSystemNotificationTurn(sequence, turnId, loopId, notificationType, status, title, detail, metadata) {
-  return {
-    id: turnId,
-    sequence,
-    turn_id: turnId,
-    loop_id: loopId,
-    kind: "message",
-    role: "system",
-    status: "completed",
-    blocks: [
-      {
-        type: "system_notification",
-        content: {
-          notification_type: notificationType,
-          status,
-          title,
-          detail,
-          metadata
-        }
-      }
-    ],
-    tool_calls: [],
-    model: null,
-    usage: null,
-    duration_ms: 0
-  };
-}
-function buildSystemNotificationBlock(notificationType, status, title, detail, metadata) {
-  return {
-    type: "system_notification",
-    content: {
-      notification_type: notificationType,
-      status,
-      title,
-      detail,
-      metadata
-    }
-  };
-}
-function buildMarkerTurn(sequence, turnId, loopId, blockType, content) {
-  return {
-    id: turnId,
-    sequence,
-    turn_id: turnId,
-    loop_id: loopId,
-    kind: "message",
-    role: "assistant",
-    status: "completed",
-    blocks: [{ type: blockType, content }],
-    tool_calls: [],
-    model: null,
-    usage: null,
-    duration_ms: 0
-  };
-}
-function buildCompactionTurn(sequence, compactionId, loopId, status, data) {
-  const tokensBefore = asInt(data.tokens_before);
-  const tokensAfter = asInt(data.tokens_after);
-  let savedRatio = null;
-  if (tokensBefore && tokensBefore > 0 && tokensAfter != null) {
-    savedRatio = 1 - tokensAfter / tokensBefore;
-  } else {
-    savedRatio = asFloat(data.saved_ratio);
-  }
-  let archivedCount = asInt(data.archived_count);
-  if (archivedCount == null && Array.isArray(data.archived_files)) {
-    archivedCount = data.archived_files.length;
-  }
-  const content = data.content;
-  const summaryFull = compactionSummaryFull(content);
-  const summaryPreview = summaryFull ? summaryFull.split("\n").map((l) => l.trim()).filter(Boolean).join(" ").slice(0, 200) : null;
-  return {
-    id: `compaction:${compactionId}`,
-    sequence,
-    turn_id: `compaction:${compactionId}`,
-    loop_id: loopId,
-    kind: "compaction",
-    role: "system",
-    status,
-    blocks: [],
-    tool_calls: [],
-    model: null,
-    usage: null,
-    duration_ms: 0,
-    compaction_id: compactionId,
-    summary_preview: summaryPreview,
-    summary_full: summaryFull,
-    archived_count: archivedCount,
-    tokens_before: tokensBefore,
-    tokens_after: tokensAfter,
-    saved_ratio: savedRatio,
-    trigger: asTrigger(data.trigger),
-    failure_reason: typeof data.reason === "string" && data.reason ? data.reason : null,
-    fallback_applied: typeof data.fallback_applied === "boolean" ? data.fallback_applied : null
-  };
-}
-function compactionSummaryFull(content) {
-  const text = String(content ?? "");
-  if (!text) return null;
-  const cleaned = text.replace("<compaction-summary>", "").replace("</compaction-summary>", "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-  return cleaned || null;
-}
-function asInt(value) {
-  if (typeof value === "boolean") return null;
-  if (typeof value === "number") return Math.trunc(value);
-  return null;
-}
-function asFloat(value) {
-  if (typeof value === "boolean") return null;
-  if (typeof value === "number") return value;
-  return null;
-}
-function asTrigger(value) {
-  if (value === "auto" || value === "manual" || value === "forced_retry") return value;
-  return null;
-}
-function setToolCallStatus(turn, toolCallId, status, result, pendingQuestionRef) {
-  if (!turn || !toolCallId) return;
-  const toolCalls = "toolCalls" in turn ? turn.toolCalls : turn.tool_calls;
-  for (let i = 0; i < toolCalls.length; i++) {
-    if (toolCalls[i].id !== toolCallId) continue;
-    toolCalls[i] = {
-      ...toolCalls[i],
-      status,
-      result,
-      pending_question_ref: pendingQuestionRef
-    };
-    return;
-  }
-}
-function applyAskUserPauseToTurn(turn, pauseToolData, toolCallId, childLoopName, description, displayNameResolver) {
-  if (!turn || !toolCallId) return;
-  const sourceLoop = childLoopName ? { loop_name: childLoopName, description } : null;
-  const toolName = String(pauseToolData.name ?? "AskUserQuestion");
-  const args = JSON.stringify(pauseToolData.arguments ?? {});
-  const result = askUserResultFromPausePayload(pauseToolData, sourceLoop);
-  const isTurnState = "toolCalls" in turn;
-  const toolCalls = isTurnState ? turn.toolCalls : turn.tool_calls;
-  const blocks = turn.blocks;
-  const displayName = displayNameResolver(toolName);
-  let found = false;
-  for (let i = 0; i < toolCalls.length; i++) {
-    if (toolCalls[i].id !== toolCallId) continue;
-    toolCalls[i] = {
-      ...toolCalls[i],
-      tool_name: toolName || toolCalls[i].tool_name,
-      display_name: displayName || toolCalls[i].display_name,
-      arguments: args || toolCalls[i].arguments
-    };
-    found = true;
-    break;
-  }
-  if (!found) {
-    toolCalls.push({
-      id: toolCallId,
-      tool_name: toolName,
-      display_name: displayName,
-      arguments: args,
-      status: "pending"
-    });
-  }
-  let blockFound = false;
-  for (let i = 0; i < blocks.length; i++) {
-    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== toolCallId) continue;
-    blocks[i] = { ...blocks[i], content: args, tool_name: toolName, display_name: displayName };
-    blockFound = true;
-    break;
-  }
-  if (!blockFound) {
-    blocks.push({
-      type: "tool_use",
-      content: args,
-      tool_call_id: toolCallId,
-      tool_name: toolName,
-      display_name: displayName
-    });
-  }
-  setToolCallStatus(turn, toolCallId, "awaiting_answer", result, null);
-  let resultBlockFound = false;
-  for (let i = 0; i < blocks.length; i++) {
-    if (blocks[i].type !== "tool_result" || blocks[i].tool_call_id !== toolCallId) continue;
-    blocks[i] = { ...blocks[i], content: result };
-    resultBlockFound = true;
-    break;
-  }
-  if (!resultBlockFound) {
-    blocks.push({
-      type: "tool_result",
-      content: result,
-      tool_call_id: toolCallId,
-      tool_name: toolName,
-      display_name: displayName
-    });
-  }
-}
-function applyChildPauseToParent(parentTurn, parentToolCallId, childLoopName, childToolCallId, description, displayNameResolver) {
-  if (!parentTurn || !parentToolCallId) return;
-  const toolCalls = "toolCalls" in parentTurn ? parentTurn.toolCalls : parentTurn.tool_calls;
-  const blocks = parentTurn.blocks;
-  const displayName = displayNameResolver("Agent");
-  let found = false;
-  for (let i = 0; i < toolCalls.length; i++) {
-    if (toolCalls[i].id !== parentToolCallId) continue;
-    toolCalls[i] = {
-      ...toolCalls[i],
-      tool_name: "Agent",
-      display_name: displayName || toolCalls[i].display_name
-    };
-    found = true;
-    break;
-  }
-  if (!found) {
-    toolCalls.push({
-      id: parentToolCallId,
-      tool_name: "Agent",
-      display_name: displayName,
-      arguments: "",
-      status: "pending"
-    });
-  }
-  let blockFound = false;
-  for (let i = 0; i < blocks.length; i++) {
-    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== parentToolCallId) continue;
-    blockFound = true;
-    break;
-  }
-  if (!blockFound) {
-    blocks.push({
-      type: "tool_use",
-      content: "",
-      tool_call_id: parentToolCallId,
-      tool_name: "Agent",
-      display_name: displayName
-    });
-  }
-  setToolCallStatus(parentTurn, parentToolCallId, "awaiting_answer", null, {
-    child_loop_name: childLoopName,
-    child_tool_call_id: childToolCallId,
-    description: description || null
-  });
-}
-function askUserResultFromPausePayload(pauseToolData, sourceLoop) {
-  const args = typeof pauseToolData.arguments === "object" && pauseToolData.arguments !== null ? pauseToolData.arguments : {};
-  const payload = { questions: args.questions ?? [] };
-  if (sourceLoop) payload.source_loop = sourceLoop;
-  return JSON.stringify(payload);
-}
-function sourceLoopFor(loopId, loopDescriptions) {
-  if (loopId === "root") return null;
-  const description = loopDescriptions.get(loopId);
-  if (!description) return null;
-  return { loop_name: loopId, description };
-}
-function normalizeChildPause(pausePayload) {
-  const rawPtd = pausePayload.pause_tool_data;
-  const pauseToolData = typeof rawPtd === "object" && rawPtd !== null ? { ...rawPtd } : { ...pausePayload };
-  let sourceLoop = pauseToolData.source_loop;
-  if (typeof sourceLoop !== "object" || sourceLoop === null) {
-    sourceLoop = pausePayload.source_loop;
-  }
-  const childLoopName = String(pausePayload.child_loop_name ?? "") || (typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.name ?? "") : "");
-  const childToolCallId = String(
-    pausePayload.child_pause_tool_call_id ?? pauseToolData.tool_call_id ?? ""
-  );
-  const description = typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.description ?? "") : "";
-  if (childLoopName && description) {
-    pauseToolData.source_loop = { name: childLoopName, description };
-  }
-  return { pauseToolData, childLoopName, childToolCallId, description };
-}
-
-// src/react/schemas/message.ts
-function inferToolStatus(resultStr) {
-  if (resultStr.includes('"Cancelled by user"')) return "cancelled";
-  try {
-    const parsed = JSON.parse(resultStr);
-    if (typeof parsed === "object" && parsed !== null) {
-      if ("error" in parsed && parsed.error) return "error";
-      const nested = parsed.result;
-      if (typeof nested === "object" && nested !== null && "error" in nested && nested.error) {
-        return "error";
-      }
-    }
-  } catch {
-  }
-  return "done";
-}
-
-// src/react/projection/state.ts
-function createTurnState(turnId, loopId, opts = {}) {
-  return {
-    turnId,
-    loopId,
-    role: "assistant",
-    model: opts.model ?? null,
-    startedAt: Date.now(),
-    contextWindow: opts.contextWindow ?? 0,
-    blocks: [],
-    toolCalls: [],
-    usage: null,
-    memoryRefs: opts.memoryRefs ?? null,
-    parentForkToolCallId: null
-  };
-}
-function snapshot(state, sequence, status) {
-  return {
-    id: state.turnId,
-    sequence,
-    turn_id: state.turnId,
-    loop_id: state.loopId,
-    kind: "message",
-    role: state.role,
-    status,
-    blocks: [...state.blocks],
-    tool_calls: [...state.toolCalls],
-    model: state.model,
-    usage: state.usage ? { ...state.usage } : null,
-    duration_ms: Math.max(0, Date.now() - state.startedAt),
-    started_at: new Date(state.startedAt).toISOString(),
-    context_window: state.contextWindow,
-    memory_refs: state.memoryRefs,
-    parent_fork_tool_call_id: state.parentForkToolCallId
-  };
-}
-var PAUSE_TOOL_NAMES = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
-function toolStatusFromResult(result) {
-  const text = typeof result === "string" ? result : Array.isArray(result) ? result.filter(
-    (p) => typeof p === "object" && p !== null && p.type === "text"
-  ).map((p) => p.text ?? "").join("\n") : String(result ?? "");
-  return inferToolStatus(text);
-}
-
-// src/react/projection/builder.ts
-var ClientProjectionBuilder = class {
-  activeTurns = /* @__PURE__ */ new Map();
-  lastTurnIds = /* @__PURE__ */ new Map();
-  latestTurns = /* @__PURE__ */ new Map();
-  loopDescriptions = /* @__PURE__ */ new Map();
-  pendingChildPauses = /* @__PURE__ */ new Map();
-  pendingMemoryRefs = /* @__PURE__ */ new Map();
-  activeCompactions = /* @__PURE__ */ new Map();
-  seq = 0;
-  syntheticCounter = 0;
-  displayNameResolver;
-  constructor(displayNameResolver) {
-    this.displayNameResolver = displayNameResolver ?? ((n) => n);
-  }
-  processBatch(events) {
-    const lastUpsertByTurn = /* @__PURE__ */ new Map();
-    const nonUpserts = [];
-    for (const event of events) {
-      const updates = this.processEvent(event);
-      if (!updates) continue;
-      for (const u of updates) {
-        if (u.kind === "upsert") {
-          lastUpsertByTurn.set(u.turn.turn_id, u);
-        } else {
-          nonUpserts.push(u);
-        }
-      }
-    }
-    return [...nonUpserts, ...lastUpsertByTurn.values()];
-  }
-  processEvent(event) {
-    const payload = event.payload;
-    const loopId = String(payload.loop_name ?? "root");
-    switch (event.type) {
-      case "memory:inject:done":
-        return this.onMemoryInject(loopId, payload);
-      case "memory:inject:none":
-        return null;
-      case "loop:turn":
-        return this.onLoopTurn(loopId, payload);
-      case "mode:change":
-        return this.onModeChange(loopId, payload);
-      case "plan:status:update":
-        return this.onPlanStatusUpdate(loopId, payload);
-      case "workspace:changed":
-        return this.onWorkspaceChanged(loopId, payload);
-      case "agent:start":
-        return this.onAgentStart(loopId, payload);
-      case "bg:started":
-        return this.onBgStarted(loopId, payload);
-      case "bg:tasks_completed":
-        return this.onBgTasksCompleted(loopId, payload);
-      case "loop:ask_user_answer":
-        return this.onAskUserAnswer(loopId, payload);
-      case "user:message":
-        return this.onUserMessage(loopId, payload);
-    }
-    if (event.type.startsWith("compaction:"))
-      return this.onCompaction(event.type, loopId, payload);
-    const state = this.activeTurns.get(loopId);
-    if (!state) {
-      if (event.type === "chat:end") {
-        this.pendingMemoryRefs.delete(loopId);
-        return null;
-      }
-      if (event.type === "agent:end") return this.onAgentEnd(null, loopId, payload);
-      return null;
-    }
-    switch (event.type) {
-      case "llm:thinking:delta":
-        return this.onDelta(state, "thinking", "", String(payload.content ?? ""));
-      case "llm:content:delta":
-        return this.onDelta(state, "text", "", String(payload.content ?? ""));
-      case "llm:tool_call:created":
-        return this.onToolCallCreated(state, payload);
-      case "llm:response:done":
-        return this.onResponseDone(state, loopId, payload);
-      case "tool:result:delta":
-        return this.onToolResultDelta(state, payload);
-      case "tool:result:done":
-        return this.onToolResultDone(state, loopId, payload);
-      case "loop:tool_ui":
-        return this.onToolUi(state, payload);
-      case "loop:tool_bridge":
-        return this.onToolBridge(state, payload);
-      case "tool:approval:required":
-        return this.onToolApprovalRequired(state, payload);
-      case "loop:child_pause":
-        return this.onChildPause(state, loopId, payload);
-      case "chat:end":
-        return this.onChatEnd(state, loopId, payload);
-      case "agent:end":
-        return this.onAgentEnd(state, loopId, payload);
-      default:
-        return null;
-    }
-  }
-  reset() {
-    this.activeTurns.clear();
-    this.lastTurnIds.clear();
-    this.latestTurns.clear();
-    this.loopDescriptions.clear();
-    this.pendingChildPauses.clear();
-    this.pendingMemoryRefs.clear();
-    this.activeCompactions.clear();
-    this.seq = 0;
-    this.syntheticCounter = 0;
-  }
-  seedSequence(maxSeq) {
-    if (maxSeq > this.seq) {
-      this.seq = maxSeq;
-    }
-  }
-  // --- Event handlers ---
-  onMemoryInject(loopId, payload) {
-    const refs = payload.memory_refs;
-    const turnId = String(payload.turn_id ?? "");
-    if (Array.isArray(refs) && refs.length > 0) {
-      this.pendingMemoryRefs.set(loopId, {
-        turnId,
-        refs: refs.map((r4) => ({
-          id: Number(r4.id),
-          content_preview: String(r4.content_preview ?? ""),
-          skill_name: r4.skill_name != null ? String(r4.skill_name) : null
-        }))
-      });
-    }
-    return null;
-  }
-  onLoopTurn(loopId, payload) {
-    let turnId = String(payload.turn_id ?? this.nextTurnId(`turn:${loopId}`));
-    let memoryRefs = null;
-    const pending = this.pendingMemoryRefs.get(loopId);
-    if (pending) {
-      this.pendingMemoryRefs.delete(loopId);
-      if (pending.turnId) turnId = pending.turnId;
-      memoryRefs = pending.refs;
-    }
-    const rawCw = payload.context_window;
-    const contextWindow = typeof rawCw === "number" && rawCw > 0 ? Math.trunc(rawCw) : 0;
-    const state = createTurnState(turnId, loopId, {
-      model: optStr(payload.model),
-      contextWindow,
-      memoryRefs
-    });
-    this.activeTurns.set(loopId, state);
-    this.lastTurnIds.set(loopId, turnId);
-    const turn = snapshot(state, this.nextSeq(), "streaming");
-    this.latestTurns.set(loopId, turn);
-    return [{ kind: "upsert", turn }];
-  }
-  onModeChange(loopId, payload) {
-    const content = {};
-    if (payload.from != null && payload.from !== "") content.from = String(payload.from);
-    if (payload.to != null && payload.to !== "") content.to = String(payload.to);
-    const turn = buildMarkerTurn(
-      this.nextSeq(),
-      this.nextTurnId("mode_change"),
-      loopId,
-      "mode_change",
-      content
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onPlanStatusUpdate(loopId, payload) {
-    let statuses = payload.statuses;
-    if (typeof statuses !== "object" || statuses === null) {
-      statuses = payload._statuses ?? {};
-    }
-    const turn = buildMarkerTurn(
-      this.nextSeq(),
-      this.nextTurnId("plan_status"),
-      loopId,
-      "plan_status",
-      { plan_yaml: payload.plan_yaml ?? "", statuses }
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onWorkspaceChanged(loopId, payload) {
-    const updates = [
-      {
-        kind: "workspace_changed",
-        loopId,
-        toolCallId: optStr(payload.tool_call_id) ?? void 0,
-        toolName: toolNameFromPayload(payload) ?? void 0
-      }
-    ];
-    const state = this.activeTurns.get(loopId);
-    if (state) {
-      const turn = snapshot(state, this.nextSeq(), "streaming");
-      this.latestTurns.set(loopId, turn);
-      this.lastTurnIds.set(loopId, turn.turn_id);
-      updates.push({ kind: "upsert", turn });
-    }
-    return updates;
-  }
-  onAgentStart(loopId, payload) {
-    const description = optStr(payload.description);
-    if (description) this.loopDescriptions.set(loopId, description);
-    const turn = buildSystemNotificationTurn(
-      this.nextSeq(),
-      this.nextTurnId("agent:start"),
-      loopId,
-      "agent:start",
-      "running",
-      `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`,
-      optStr(payload.prompt),
-      {
-        skill_id: optStr(payload.skill_id),
-        description: optStr(payload.description),
-        parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id)
-      }
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onBgStarted(loopId, payload) {
-    const taskId = optStr(payload.task_id) ?? "";
-    const command = optStr(payload.command);
-    const description = optStr(payload.description);
-    const turn = buildSystemNotificationTurn(
-      this.nextSeq(),
-      this.nextTurnId("bg:started"),
-      loopId,
-      "bg:started",
-      "running",
-      description ?? `Background: ${taskId || "task"}`,
-      command,
-      { task_id: taskId, command, description }
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onBgTasksCompleted(loopId, payload) {
-    const taskIds = Array.isArray(payload.task_ids) ? payload.task_ids : [];
-    const count = typeof payload.count === "number" ? payload.count : taskIds.length;
-    const detail = taskIds.map(String).join(", ");
-    const turn = buildSystemNotificationTurn(
-      this.nextSeq(),
-      this.nextTurnId("bg:tasks_completed"),
-      loopId,
-      "bg:tasks_completed",
-      "done",
-      `Background tasks completed (${count})`,
-      detail || null,
-      { task_ids: taskIds, count }
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onAskUserAnswer(loopId, payload) {
-    const toolCallId = String(payload.tool_call_id ?? "");
-    const pending = this.pendingChildPauses.get(toolCallId);
-    const parentLoopId = pending?.parentLoopName;
-    if (pending) {
-      this.pendingChildPauses.delete(toolCallId);
-      const childTurn = this.activeTurns.get(pending.childLoopName) ?? this.latestTurns.get(pending.childLoopName);
-      setToolCallStatus(childTurn, pending.childToolCallId, "done", null, null);
-      const parentTurn = this.activeTurns.get(pending.parentLoopName) ?? this.latestTurns.get(pending.parentLoopName);
-      setToolCallStatus(parentTurn, pending.parentToolCallId, "done", null, null);
-    }
-    const directTurn = this.activeTurns.get(loopId) ?? this.latestTurns.get(loopId);
-    setToolCallStatus(directTurn, toolCallId, "done", null, null);
-    return this.collectLoopUpdates(loopId, parentLoopId);
-  }
-  onUserMessage(_loopId, payload) {
-    const entryId = String(payload.entry_id ?? this.nextTurnId("user"));
-    const displayContent = payload.display_content ?? payload.content ?? "";
-    const turn = {
-      id: entryId,
-      sequence: this.nextSeq(),
-      turn_id: entryId,
-      loop_id: "root",
-      kind: "message",
-      role: "user",
-      status: "completed",
-      blocks: [{ type: "text", content: displayContent }],
-      tool_calls: [],
-      model: null,
-      usage: null,
-      duration_ms: 0
-    };
-    return [{ kind: "upsert", turn }];
-  }
-  // --- Delta / streaming events ---
-  onDelta(state, blockType, _toolCallId, content) {
-    if (!content) return null;
-    appendTextBlock(state, blockType, content);
-    return this.syncPatch(state);
-  }
-  onToolCallCreated(state, payload) {
-    if ("arguments_delta" in payload) {
-      const delta = String(payload.arguments_delta ?? "");
-      const toolCallId2 = String(payload.id ?? "");
-      if (delta && toolCallId2) {
-        appendToolCallArguments(state, toolCallId2, delta);
-        return this.syncPatch(state);
-      }
-      return null;
-    }
-    const toolCallId = String(payload.id ?? "");
-    const toolName = toolNameFromPayload(payload);
-    const displayName = String(payload.display_name ?? "") || this.displayNameResolver(toolName);
-    const args = toolArgsFromPayload(payload);
-    upsertToolCall(state, toolCallId, toolName, displayName, args);
-    return this.syncPatch(state);
-  }
-  onResponseDone(state, loopId, payload) {
-    const model = optStr(payload.model);
-    if (model) state.model = model;
-    if (typeof payload.usage === "object" && payload.usage !== null) {
-      state.usage = { ...payload.usage };
-    }
-    const toolCalls = payload.tool_calls;
-    if (Array.isArray(toolCalls)) {
-      for (const raw of toolCalls) {
-        if (typeof raw !== "object" || raw === null) continue;
-        const tc = raw;
-        const fn = tc.function ?? {};
-        const toolName = String(fn.name ?? "");
-        const displayName = String(tc.display_name ?? "") || this.displayNameResolver(toolName);
-        upsertToolCall(
-          state,
-          String(tc.id ?? ""),
-          toolName,
-          displayName,
-          String(fn.arguments ?? "")
-        );
-      }
-    }
-    if (state.toolCalls.length === 0) {
-      return this.finalize(loopId, "completed");
-    }
-    return this.syncPatch(state);
-  }
-  onToolResultDone(state, loopId, payload) {
-    const toolCallId = String(payload.tool_call_id ?? "");
-    const content = payload.content ?? "";
-    const status = toolStatusFromResult(content);
-    const rawDuration = payload.duration_ms;
-    const durationMs = typeof rawDuration === "number" && rawDuration >= 0 ? Math.round(rawDuration) : null;
-    const sl = sourceLoopFor(state.loopId, this.loopDescriptions);
-    applyToolResult(state, toolCallId, content, status, durationMs, sl);
-    if (this.shouldFinalizeAfterToolResults(state)) {
-      return this.finalize(loopId, "completed");
-    }
-    return this.syncPatch(state);
-  }
-  onToolResultDelta(state, payload) {
-    appendToolResultDelta(
-      state,
-      String(payload.tool_call_id ?? ""),
-      String(payload.content ?? "")
-    );
-    return this.syncPatch(state);
-  }
-  onToolUi(state, payload) {
-    const toolCallId = String(payload.tool_call_id ?? "");
-    const ui = payload.ui;
-    if (toolCallId && typeof ui === "object" && ui !== null) {
-      state.blocks.push({
-        type: "tool_ui",
-        content: ui,
-        tool_call_id: toolCallId
-      });
-    }
-    return this.syncPatch(state);
-  }
-  onToolBridge(state, payload) {
-    const bridge = payload.bridge;
-    if (typeof bridge !== "object" || bridge === null) return null;
-    state.blocks.push({
-      type: "tool_bridge",
-      content: bridge,
-      tool_call_id: String(payload.tool_call_id ?? "") || null
-    });
-    return this.syncPatch(state);
-  }
-  onToolApprovalRequired(state, payload) {
-    const toolCallId = String(payload.tool_call_id ?? "");
-    const toolName = String(payload.tool_name ?? "");
-    const displayName = this.displayNameResolver(toolName);
-    upsertToolCall(state, toolCallId, toolName, displayName, "");
-    return this.syncPatch(state);
-  }
-  onChildPause(state, loopId, payload) {
-    const pauseToolData = payload.pause_tool_data;
-    if (typeof pauseToolData !== "object" || pauseToolData === null)
-      return this.syncPatch(state);
-    const ptd = pauseToolData;
-    const sourceLoop = ptd.source_loop;
-    if (typeof sourceLoop === "object" && sourceLoop) {
-      const slName = String(sourceLoop.name ?? "");
-      const slDesc = optStr(sourceLoop.description);
-      if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
-    }
-    const { childLoopName, childToolCallId, description } = normalizeChildPause(payload);
-    if (!childToolCallId) return this.syncPatch(state);
-    const existing = this.pendingChildPauses.get(childToolCallId);
-    const parentLoopName = String(
-      payload.parent_loop_name ?? existing?.parentLoopName ?? "root"
-    );
-    const parentToolCallId = String(
-      payload.parent_fork_tool_call_id ?? existing?.parentToolCallId ?? ""
-    );
-    const resolvedChildLoopName = String(payload.child_loop_name ?? "") || existing?.childLoopName || childLoopName || loopId;
-    this.pendingChildPauses.set(childToolCallId, {
-      parentLoopName,
-      parentToolCallId,
-      childLoopName: resolvedChildLoopName,
-      childToolCallId,
-      description: description || existing?.description || ""
-    });
-    applyAskUserPauseToTurn(
-      state,
-      ptd,
-      childToolCallId,
-      resolvedChildLoopName,
-      this.pendingChildPauses.get(childToolCallId).description,
-      this.displayNameResolver
-    );
-    const parentTurn = this.activeTurns.get(parentLoopName) ?? this.latestTurns.get(parentLoopName);
-    if (parentTurn) {
-      applyChildPauseToParent(
-        parentTurn,
-        parentToolCallId,
-        resolvedChildLoopName,
-        childToolCallId,
-        this.pendingChildPauses.get(childToolCallId).description,
-        this.displayNameResolver
-      );
-    }
-    return this.collectLoopUpdates(loopId, parentLoopName);
-  }
-  onChatEnd(state, loopId, payload) {
-    const status = String(payload.status ?? "completed");
-    const pauseToolData = payload.pause_tool_data;
-    if (typeof pauseToolData === "object" && pauseToolData !== null) {
-      const ptd = pauseToolData;
-      const pauseToolName = String(ptd.name ?? "");
-      const normalized = pauseToolName.includes(":") ? pauseToolName.split(":").pop() : pauseToolName;
-      const sourceLoop = ptd.source_loop;
-      if (typeof sourceLoop === "object" && sourceLoop) {
-        const slName = String(sourceLoop.name ?? "");
-        const slDesc = optStr(sourceLoop.description);
-        if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
-        if (status === "paused" && slName) {
-          applyChildPauseToParent(
-            state,
-            String(ptd.parent_fork_tool_call_id ?? ""),
-            slName,
-            String(ptd.tool_call_id ?? ""),
-            slDesc ?? "",
-            this.displayNameResolver
-          );
-          const childTurn = this.activeTurns.get(slName);
-          if (childTurn) {
-            applyAskUserPauseToTurn(
-              childTurn,
-              ptd,
-              String(ptd.tool_call_id ?? ""),
-              slName,
-              slDesc ?? "",
-              this.displayNameResolver
-            );
-          }
-        }
-      } else if (status === "paused" && normalized === "AskUserQuestion") {
-        applyAskUserPauseToTurn(
-          state,
-          ptd,
-          String(ptd.tool_call_id ?? ""),
-          "",
-          "",
-          this.displayNameResolver
-        );
-      }
-    }
-    const finalStatus = { completed: "completed", paused: "paused", failed: "failed", interrupted: "interrupted" }[status];
-    if (!finalStatus) return null;
-    if (!this.activeTurns.has(loopId)) {
-      this.pendingMemoryRefs.delete(loopId);
-    }
-    return this.finalize(loopId, finalStatus);
-  }
-  onAgentEnd(state, loopId, payload) {
-    const ok = payload.ok !== false;
-    const status = ok ? "done" : "error";
-    const title = `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`;
-    const detail = optStr(payload.error);
-    const metadata = {
-      skill_id: optStr(payload.skill_id),
-      description: optStr(payload.description),
-      parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id),
-      ok
-    };
-    if (state) {
-      state.blocks.push(buildSystemNotificationBlock("agent:end", status, title, detail, metadata));
-      return this.finalize(loopId, ok ? "completed" : "failed");
-    }
-    const turn = buildSystemNotificationTurn(
-      this.nextSeq(),
-      this.nextTurnId("agent:end"),
-      loopId,
-      "agent:end",
-      status,
-      title,
-      detail,
-      metadata
-    );
-    return [{ kind: "upsert", turn }];
-  }
-  onCompaction(eventType, loopId, payload) {
-    const compactionId = String(payload.compaction_id ?? "");
-    if (!compactionId) return null;
-    const current = {
-      ...this.activeCompactions.get(compactionId) ?? {},
-      ...payload,
-      loop_id: loopId
-    };
-    let status;
-    switch (eventType) {
-      case "compaction:start":
-        status = "streaming";
-        this.activeCompactions.set(compactionId, current);
-        break;
-      case "compaction:end":
-        status = "completed";
-        this.activeCompactions.delete(compactionId);
-        break;
-      case "compaction:abort":
-        status = "interrupted";
-        this.activeCompactions.delete(compactionId);
-        break;
-      case "compaction:error":
-        status = "failed";
-        this.activeCompactions.delete(compactionId);
-        break;
-      default:
-        status = "streaming";
-        this.activeCompactions.set(compactionId, current);
-    }
-    const turn = buildCompactionTurn(this.nextSeq(), compactionId, loopId, status, current);
-    return [{ kind: "upsert", turn }];
-  }
-  // --- Internal helpers ---
-  syncPatch(state) {
-    const turn = snapshot(state, this.nextSeq(), "streaming");
-    this.latestTurns.set(state.loopId, turn);
-    this.lastTurnIds.set(state.loopId, turn.turn_id);
-    return [{ kind: "upsert", turn }];
-  }
-  finalize(loopId, status) {
-    const state = this.activeTurns.get(loopId);
-    if (!state) return null;
-    this.activeTurns.delete(loopId);
-    const turn = snapshot(state, this.nextSeq(), status);
-    this.lastTurnIds.set(loopId, turn.turn_id);
-    this.latestTurns.set(loopId, turn);
-    return [{ kind: "upsert", turn }];
-  }
-  shouldFinalizeAfterToolResults(state) {
-    if (state.toolCalls.length === 0) return true;
-    if (state.toolCalls.some((tc) => tc.status === "pending")) return false;
-    return !state.toolCalls.some((tc) => {
-      const normalized = tc.tool_name.includes(":") ? tc.tool_name.split(":").pop() : tc.tool_name;
-      return PAUSE_TOOL_NAMES.has(normalized);
-    });
-  }
-  collectLoopUpdates(...loopIds) {
-    const updates = [];
-    for (const loopId of loopIds) {
-      if (!loopId) continue;
-      const state = this.activeTurns.get(loopId);
-      if (state) {
-        updates.push(...this.syncPatch(state));
-        continue;
-      }
-      const proj = this.latestTurns.get(loopId);
-      if (proj) {
-        const updated = { ...proj, sequence: this.nextSeq() };
-        this.latestTurns.set(loopId, updated);
-        updates.push({ kind: "upsert", turn: updated });
-      }
-    }
-    return updates;
-  }
-  nextSeq() {
-    return ++this.seq;
-  }
-  nextTurnId(prefix) {
-    this.syntheticCounter++;
-    const hex = Math.random().toString(16).slice(2, 10);
-    return `${prefix}:${this.syntheticCounter}:${hex}`;
-  }
-};
-function optStr(value) {
-  if (value == null || value === "") return null;
-  return String(value);
-}
-function toolNameFromPayload(payload) {
-  const fn = payload.function;
-  if (typeof fn === "object" && fn !== null) {
-    return String(fn.name ?? "");
-  }
-  return String(payload.tool_name ?? "");
-}
-function toolArgsFromPayload(payload) {
-  const fn = payload.function;
-  if (typeof fn === "object" && fn !== null) {
-    return String(fn.arguments ?? "");
-  }
-  return "";
-}
-
 // src/react/stores/auth-store.ts
 import { create as create6 } from "zustand";
 import { createJSONStorage, persist } from "zustand/middleware";
@@ -4629,4 +3532,4 @@ export {
   bootstrapBladeClient,
   getBootstrappedClient
 };
-//# sourceMappingURL=chunk-SBASG3M2.js.map
+//# sourceMappingURL=chunk-UWNQ4PXK.js.map