@blade-hq/agent-kit 1.0.27 → 1.0.28

package/dist/{chunk-34GDDOWY.js → chunk-YJ6BX3FU.js}

@@ -71,6 +71,30 @@ async function readErrorDetail(response) {
   }
 }
 
+// src/client/resources/app-dev-templates.ts
+var AppDevTemplatesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(params) {
+    const query = new URLSearchParams();
+    if (typeof params?.offset === "number") query.set("offset", String(params.offset));
+    if (typeof params?.limit === "number") query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return this.client.json("GET", `/api/app-dev/templates${suffix}`);
+  }
+  get(slug) {
+    return this.client.json("GET", `/api/app-dev/templates/${encodeURIComponent(slug)}`);
+  }
+  getMediaUrl(slug, path) {
+    const encodedPath = path.split("/").map((part) => encodeURIComponent(part)).join("/");
+    return this.client.buildAuthedUrl(
+      `/api/app-dev/templates/${encodeURIComponent(slug)}/media/${encodedPath}`
+    );
+  }
+};
+
 // src/client/resources/auth.ts
 var AuthResource = class {
   constructor(client) {
@@ -382,10 +406,12 @@ var ModelOption = type({
   id: "string",
   label: "string",
   "inputModalities?": "string[]",
-  "supportsImage?": "boolean"
+  "supportsImage?": "boolean",
+  "thinkingAvailable?": "boolean"
 });
 var ModelsConfig = type({
   default: "string",
+  "thinkingAvailable?": "boolean",
   models: ModelOption.array()
 });
 var ModelsResource = class {
@@ -506,6 +532,1326 @@ var RegistryResource = class {
   }
 };
 
+// src/client/shared/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/client/shared/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/client/shared/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((r) => ({
+          id: Number(r.id),
+          content_preview: String(r.content_preview ?? ""),
+          skill_name: r.skill_name != null ? String(r.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/client/shared/projection/history.ts
+function projectHistory(entries) {
+  const turns = [];
+  const toolOwners = /* @__PURE__ */ new Map();
+  const latestAssistantByLoop = /* @__PURE__ */ new Map();
+  const pendingChildPauses = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  for (const entry of entries) {
+    const kind = String(entry.kind ?? "");
+    const loopId = String(entry.loop_name ?? "root");
+    const id = String(entry.id ?? `history-${sequence + 1}`);
+    if (kind === "message" && isRecord2(entry.message)) {
+      const message = entry.message;
+      const role = String(message.role ?? "");
+      if (role === "tool") {
+        const toolCallId = String(message.tool_call_id ?? "");
+        const owner = toolOwners.get(toolCallId);
+        const toolCall = owner?.tool_calls.find((item) => item.id === toolCallId);
+        if (owner && toolCall) {
+          toolCall.status = message._error ? "error" : inferToolStatus(String(message.content ?? ""));
+          toolCall.result = message.content ?? "";
+          owner.blocks.push({
+            type: "tool_result",
+            content: message.content ?? "",
+            tool_call_id: toolCallId
+          });
+        }
+        continue;
+      }
+      if (role !== "user" && role !== "assistant" && role !== "system") continue;
+      const toolCalls = role === "assistant" ? buildToolCalls(message.tool_calls) : [];
+      const blocks = buildBlocks(message, toolCalls);
+      const turn = {
+        id,
+        sequence: ++sequence,
+        turn_id: id,
+        loop_id: loopId,
+        kind: "message",
+        role,
+        status: message._error ? "failed" : "completed",
+        blocks,
+        tool_calls: toolCalls,
+        model: stringOrNull(message.model),
+        usage: isRecord2(message._usage) ? { ...message._usage } : null,
+        duration_ms: numberOrZero(message._duration_ms),
+        started_at: typeof entry.timestamp === "string" ? entry.timestamp : void 0
+      };
+      turns.push(turn);
+      if (role === "assistant") latestAssistantByLoop.set(loopId, turn);
+      for (const toolCall of toolCalls) toolOwners.set(toolCall.id, turn);
+      continue;
+    }
+    if (kind === "mode_change") {
+      turns.push(markerTurn(id, ++sequence, loopId, "mode_change", entry.data ?? {}));
+    } else if (kind === "plan_status") {
+      const data = entry.data ?? {};
+      turns.push(
+        markerTurn(id, ++sequence, loopId, "plan_status", {
+          plan_yaml: data.plan_yaml ?? "",
+          statuses: data.statuses ?? data._statuses ?? {}
+        })
+      );
+    } else if (kind === "tool_ui" || kind === "tool_bridge") {
+      const data = entry.data ?? {};
+      const toolCallId = String(data.tool_call_id ?? "");
+      const owner = toolOwners.get(toolCallId) ?? findLatestAssistant(turns, loopId);
+      const content = kind === "tool_ui" ? data.ui : data.bridge;
+      if (owner && content !== void 0) {
+        owner.blocks.push({
+          type: kind,
+          content,
+          tool_call_id: toolCallId || null
+        });
+      }
+    } else if (kind === "compaction" || kind === "tool_result_archive") {
+      const data = entry.data ?? {};
+      const compactionId = String(data.compaction_id ?? entry.id ?? `history-${sequence + 1}`);
+      let content = isRecord2(entry.message) ? entry.message.content : void 0;
+      if (kind === "tool_result_archive") {
+        const archivedCount = Array.isArray(data.archived_files) ? data.archived_files.length : 0;
+        content = `<compaction-summary>
+\u5DF2\u5F52\u6863 ${archivedCount} \u4E2A\u5927\u578B\u5DE5\u5177\u7ED3\u679C\u3002
+</compaction-summary>`;
+      }
+      turns.push(
+        buildCompactionTurn(++sequence, compactionId, loopId, "completed", {
+          ...data,
+          content
+        })
+      );
+    } else if (kind === "child_pause") {
+      const data = entry.data ?? {};
+      const sourceLoop = isRecord2(data.source_loop) ? data.source_loop : {};
+      const childLoopId = String(data.child_loop_name ?? sourceLoop.name ?? "");
+      const childToolCallId = String(data.child_pause_tool_call_id ?? "");
+      const parentToolCallId = String(data.parent_fork_tool_call_id ?? "");
+      const pauseToolData = isRecord2(data.pause_tool_data) ? data.pause_tool_data : {};
+      const description = String(sourceLoop.description ?? "");
+      applyAskUserPauseToTurn(
+        latestAssistantByLoop.get(childLoopId),
+        pauseToolData,
+        childToolCallId,
+        childLoopId,
+        description,
+        (name) => name
+      );
+      applyChildPauseToParent(
+        latestAssistantByLoop.get(loopId),
+        parentToolCallId,
+        childLoopId,
+        childToolCallId,
+        description,
+        (name) => name
+      );
+      if (childToolCallId) {
+        pendingChildPauses.set(childToolCallId, {
+          childLoopId,
+          parentLoopId: loopId,
+          parentToolCallId
+        });
+      }
+    } else if (kind === "ask_user_answer") {
+      const data = entry.data ?? {};
+      const toolCallId = String(data.tool_call_id ?? "");
+      const pending = pendingChildPauses.get(toolCallId);
+      if (pending) {
+        setToolCallStatus(latestAssistantByLoop.get(pending.childLoopId), toolCallId, "done", null, null);
+        setToolCallStatus(
+          latestAssistantByLoop.get(pending.parentLoopId),
+          pending.parentToolCallId,
+          "done",
+          null,
+          null
+        );
+        pendingChildPauses.delete(toolCallId);
+      } else {
+        setToolCallStatus(latestAssistantByLoop.get(loopId), toolCallId, "done", null, null);
+      }
+      turns.push(
+        markerTurn(
+          id,
+          ++sequence,
+          loopId,
+          "ask_user_answer",
+          data,
+          toolCallId || null
+        )
+      );
+    }
+  }
+  return turns;
+}
+function buildToolCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord2).map((raw) => {
+    const fn = isRecord2(raw.function) ? raw.function : {};
+    const name = String(fn.name ?? "");
+    return {
+      id: String(raw.id ?? ""),
+      tool_name: name,
+      display_name: String(raw.display_name ?? name),
+      arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? {}),
+      status: "running",
+      result: null
+    };
+  });
+}
+function buildBlocks(message, toolCalls) {
+  const stored = message._blocks;
+  const blocks = [];
+  if (Array.isArray(stored)) {
+    for (const raw of stored) {
+      if (!isRecord2(raw)) continue;
+      const type3 = String(raw.type ?? "");
+      if (type3 === "thinking") blocks.push({ type: type3, content: raw.thinking ?? raw.content ?? "" });
+      if (type3 === "text") blocks.push({ type: type3, content: raw.text ?? raw.content ?? "" });
+    }
+  } else if (message.content !== void 0 && message.content !== "") {
+    blocks.push({ type: "text", content: message.content });
+  }
+  for (const toolCall of toolCalls) {
+    blocks.push({
+      type: "tool_use",
+      content: { name: toolCall.tool_name, arguments: toolCall.arguments },
+      tool_call_id: toolCall.id
+    });
+  }
+  return blocks;
+}
+function markerTurn(id, sequence, loopId, type3, content, toolCallId = null) {
+  return {
+    id,
+    sequence,
+    turn_id: id,
+    loop_id: loopId,
+    kind: type3,
+    role: "system",
+    status: "completed",
+    blocks: [{ type: type3, content, tool_call_id: toolCallId }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function numberOrZero(value) {
+  return typeof value === "number" ? value : 0;
+}
+function findLatestAssistant(turns, loopId) {
+  for (let index = turns.length - 1; index >= 0; index -= 1) {
+    const turn = turns[index];
+    if (turn?.role === "assistant" && turn.loop_id === loopId) return turn;
+  }
+  return void 0;
+}
+
 // src/client/resources/runs.ts
 var SYSTEM_ERROR_CHAT_END_GRACE_MS2 = 1e3;
 var RunsResource = class {
@@ -524,6 +1870,7 @@ var RunsResource = class {
       let started = false;
       let chatRunId;
       let systemErrorTimeout = null;
+      const projectionBuilder = new ClientProjectionBuilder();
       const timeout = setTimeout(() => {
         fail(new Error(`run timed out after ${timeoutMs}ms`));
       }, timeoutMs);
@@ -534,9 +1881,7 @@ var RunsResource = class {
           systemErrorTimeout = null;
         }
         socket.off("chat:start", onChatStart);
-        socket.off("turn:start", onTurnStart);
-        socket.off("turn:patch", onTurnPatch);
-        socket.off("turn:end", onTurnEnd);
+        socket.off("turn:events", onTurnEvents);
         socket.off("chat:end", onChatEnd);
         socket.off("system:error", onSystemError);
         if (sendStop && !stopSent) {
@@ -574,17 +1919,13 @@ var RunsResource = class {
         started = true;
         events.push({ type: "chat:start", payload });
       }
-      function onTurnStart(payload) {
-        if (!isSessionEvent(payload, sessionId)) return;
-        events.push({ type: "turn:start", payload });
-      }
-      function onTurnPatch(payload) {
-        if (!isSessionEvent(payload, sessionId)) return;
-        events.push({ type: "turn:patch", payload });
-      }
-      function onTurnEnd(payload) {
-        if (!isSessionEvent(payload, sessionId)) return;
-        events.push({ type: "turn:end", payload });
+      function onTurnEvents(payload) {
+        if (!isSessionEvent(payload, sessionId) || !payload.events?.length) return;
+        for (const update of projectionBuilder.processBatch(payload.events)) {
+          if (update.kind === "upsert") {
+            events.push({ type: "turn:end", payload: { ...update.turn, session_id: sessionId } });
+          }
+        }
       }
       function onSystemError(payload) {
         if (!isSessionEvent(payload, sessionId)) return;
@@ -613,12 +1954,10 @@ var RunsResource = class {
         finish(payload);
       }
       socket.on("chat:start", onChatStart);
-      socket.on("turn:start", onTurnStart);
-      socket.on("turn:patch", onTurnPatch);
-      socket.on("turn:end", onTurnEnd);
+      socket.on("turn:events", onTurnEvents);
       socket.on("chat:end", onChatEnd);
       socket.on("system:error", onSystemError);
-      socket.emit("session:subscribe", { session_id: sessionId, event_format: "projection" });
+      socket.emit("session:subscribe", { session_id: sessionId, event_format: "raw" });
       socket.emit("chat:send", buildChatSendPayload(sessionId, message, options));
     });
   }
@@ -645,16 +1984,16 @@ function buildChatSendPayload(sessionId, message, options) {
 }
 function collectConfigSnapshot(events) {
   const chatStart = events.find((event) => {
-    if (!isRecord2(event) || event.type !== "chat:start") return false;
-    return isRecord2(event.payload);
+    if (!isRecord3(event) || event.type !== "chat:start") return false;
+    return isRecord3(event.payload);
   });
-  if (!isRecord2(chatStart) || !isRecord2(chatStart.payload)) {
+  if (!isRecord3(chatStart) || !isRecord3(chatStart.payload)) {
     return {};
   }
   return chatStart.payload;
 }
 function errorMessageFromResult2(result) {
-  if (isRecord2(result) && typeof result.err_msg === "string" && result.err_msg) {
+  if (isRecord3(result) && typeof result.err_msg === "string" && result.err_msg) {
     return result.err_msg;
   }
   return null;
@@ -662,7 +2001,7 @@ function errorMessageFromResult2(result) {
 function isSessionEvent(payload, sessionId) {
   return !payload.session_id || payload.session_id === sessionId;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function ensureSocketConnected2(socket, timeoutMs, detail) {
@@ -834,17 +2173,22 @@ var SessionsResource = class {
   revokeShare(sessionId, token) {
     return this.client.json("DELETE", `/api/sessions/${sessionId}/share/${encodeURIComponent(token)}`);
   }
-  getSharedSession(token) {
-    return this.client.jsonFromInit(`/api/share/${encodeURIComponent(token)}`, {
+  async getSharedSession(token) {
+    const entries = await this.client.jsonFromInit(`/api/share/${encodeURIComponent(token)}`, {
       credentials: "omit",
       headers: { Accept: "application/json" }
     });
+    return projectHistory(entries);
   }
   getSessionTasks(sessionId) {
     return this.client.json("GET", `/api/sessions/${sessionId}/tasks`);
   }
-  getSessionTurns(sessionId) {
-    return this.client.json("GET", `/api/sessions/${sessionId}/messages`);
+  async getSessionTurns(sessionId) {
+    const entries = await this.client.json(
+      "GET",
+      `/api/sessions/${sessionId}/messages`
+    );
+    return projectHistory(entries);
   }
   getSessionContextStats(sessionId, init) {
     return this.client.jsonFromInit(`/api/sessions/${sessionId}/context-stats`, init);
@@ -1113,7 +2457,7 @@ var SolutionsResource = class {
   }
 };
 function toPreparedSolution(payload) {
-  const data = isRecord3(payload) ? payload : {};
+  const data = isRecord4(payload) ? payload : {};
   const roles = Array.isArray(data.roles) ? data.roles.filter((role) => typeof role === "string") : [];
   return {
     kind: "prepared",
@@ -1127,7 +2471,7 @@ function stringField(data, key) {
   const value = data[key];
   return typeof value === "string" ? value : null;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseContentDispositionFilename(header) {
@@ -1233,6 +2577,7 @@ var BladeClient = class {
   storeSocketTokenResolver = null;
   options;
   apiKeys;
+  appDevTemplates;
   auth;
   envBuckets;
   gis;
@@ -1253,6 +2598,7 @@ var BladeClient = class {
       baseUrl: normalizeBaseUrl(options.baseUrl)
     };
     this.apiKeys = new ApiKeysResource(this);
+    this.appDevTemplates = new AppDevTemplatesResource(this);
     this.auth = new AuthResource(this);
     this.envBuckets = new EnvBucketsResource(this);
     this.gis = new GisResource(this);
@@ -1532,6 +2878,7 @@ function parseXhrHeaders(rawHeaders) {
 export {
   BladeApiError,
   ApiKeysResource,
+  AppDevTemplatesResource,
   AuthResource,
   GisResource,
   HeadlessError,
@@ -1544,6 +2891,7 @@ export {
   REGISTRY_PREFIX,
   normalizeResource,
   RegistryResource,
+  ClientProjectionBuilder,
   RunsResource,
   ScenariosResource,
   SessionsResource,
@@ -1553,4 +2901,4 @@ export {
   createSocket,
   BladeClient
 };
-//# sourceMappingURL=chunk-34GDDOWY.js.map
+//# sourceMappingURL=chunk-YJ6BX3FU.js.map