@yourgpt/copilot-sdk 2.1.4 → 2.1.5-alpha.0

package/dist/{chunk-N6VZ7FOW.cjs → chunk-76RE7AJE.cjs}

@@ -1,11 +1,14 @@
 'use strict';
 
-var chunkOQPRIB73_cjs = require('./chunk-OQPRIB73.cjs');
+var chunkI3SQUNTT_cjs = require('./chunk-I3SQUNTT.cjs');
 var chunkJGPDQDY4_cjs = require('./chunk-JGPDQDY4.cjs');
-var react = require('react');
+var chunkBJYA5NDL_cjs = require('./chunk-BJYA5NDL.cjs');
+var React2 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var z = require('zod');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -24,6 +27,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 
 // src/chat/types/tool.ts
@@ -141,15 +145,6 @@ function parseSSELine(line) {
 function isStreamDone(chunk) {
   return chunk.type === "done" || chunk.type === "error";
 }
-function requiresToolExecution(chunk) {
-  if (chunk.type === "done" && chunk.requiresAction) {
-    return true;
-  }
-  if (chunk.type === "tool_calls") {
-    return true;
-  }
-  return false;
-}
 
 // src/chat/functions/stream/processChunk.ts
 function processStreamChunk(chunk, state) {
@@ -284,13 +279,14 @@ function createStreamState(messageId) {
 function generateMessageId() {
   return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
 }
-function createUserMessage(content, attachments) {
+function createUserMessage(content, attachments, options) {
   return {
     id: generateMessageId(),
     role: "user",
     content,
     attachments,
-    createdAt: /* @__PURE__ */ new Date()
+    createdAt: /* @__PURE__ */ new Date(),
+    ...options?.parentId !== void 0 ? { parentId: options.parentId } : {}
   };
 }
 function streamStateToMessage(state) {
@@ -329,12 +325,13 @@ function streamStateToMessage(state) {
     metadata: Object.keys(metadata).length > 0 ? metadata : void 0
   };
 }
-function createEmptyAssistantMessage(id) {
+function createEmptyAssistantMessage(id, options) {
   return {
     id: generateMessageId(),
     role: "assistant",
     content: "",
-    createdAt: /* @__PURE__ */ new Date()
+    createdAt: /* @__PURE__ */ new Date(),
+    ...options?.parentId !== void 0 ? { parentId: options.parentId } : {}
   };
 }
 
@@ -403,6 +400,7 @@ var HttpTransport = class {
           tools: request.tools,
           actions: request.actions,
           streaming: this.config.streaming,
+          __skills: request.__skills,
           ...resolved.configBody,
           ...request.body
         }),
@@ -543,17 +541,443 @@ var HttpTransport = class {
   }
 };
 
-// src/chat/classes/AbstractChat.ts
-function buildToolResultContentForAI(result, tool2, args) {
-  if (typeof result === "string") return result;
-  const typedResult = result;
+// src/chat/optimizations.ts
+var DEFAULT_CHARS_PER_TOKEN = 4;
+var DEFAULT_SAFETY_MARGIN = 1.2;
+var DEFAULT_INPUT_HEADROOM_RATIO = 0.75;
+var DEFAULT_SYSTEM_PROMPT_SHARE = 0.15;
+var DEFAULT_HISTORY_SHARE = 0.5;
+var DEFAULT_TOOL_RESULTS_SHARE = 0.3;
+var DEFAULT_TOOL_DEFINITIONS_SHARE = 0.05;
+var DEFAULT_MAX_TOOL_RESULT_CONTEXT_SHARE = 0.3;
+var DEFAULT_TOOL_RESULT_HARD_MAX_CHARS = 4e5;
+var DEFAULT_TOOL_RESULT_MIN_KEEP_CHARS = 2e3;
+var DEFAULT_TOOL_RESULT_STRATEGY = "head-tail";
+var DEFAULT_RECENT_HISTORY_PRESERVE = 6;
+var TOOL_RESULT_TRUNCATION_NOTICE = "\n\n[tool result truncated to fit prompt budget]";
+var TOOL_RESULT_COMPACTION_NOTICE = "[tool result compacted to preserve context budget]";
+var SYSTEM_PROMPT_TRUNCATION_NOTICE = "\n\n[system prompt truncated to fit prompt budget]";
+var HISTORY_SUMMARY_HEADER = "Conversation summary of earlier context:";
+var HISTORY_SUMMARY_COMPACTION_NOTICE = "\n\n[summary compacted to preserve context continuity]";
+var DEFAULT_SUMMARY_TRIGGER = 12;
+var DEFAULT_SUMMARY_CHUNK_SIZE = 10;
+var DEFAULT_SUMMARY_MAX_CHARS = 1600;
+var SUMMARY_STOP_WORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "again",
+  "also",
+  "because",
+  "been",
+  "before",
+  "being",
+  "could",
+  "from",
+  "have",
+  "into",
+  "just",
+  "more",
+  "need",
+  "only",
+  "over",
+  "same",
+  "some",
+  "than",
+  "that",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "under",
+  "very",
+  "want",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "with",
+  "would",
+  "your"
+]);
+function clampRatio(value, fallback) {
+  if (!Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function stringifyContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value == null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function abbreviateText(text, maxChars = 220) {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(1, maxChars - 3)).trimEnd()}...`;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9_\s-]/g, " ").split(/\s+/).filter((token) => token.length > 1);
+}
+function estimateTokens(text, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+  if (!text) {
+    return 0;
+  }
+  return Math.ceil(text.length / Math.max(1, charsPerToken));
+}
+function estimateMessageTokens(message, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+  const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? "");
+  const toolCalls = message.tool_calls ? JSON.stringify(message.tool_calls) : "";
+  const attachments = message.attachments ? JSON.stringify(message.attachments) : "";
+  return estimateTokens(
+    `${message.role}
+${content}
+${toolCalls}
+${attachments}`,
+    charsPerToken
+  );
+}
+function estimateToolTokens(tool2, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+  return estimateTokens(JSON.stringify(tool2), charsPerToken);
+}
+function buildToolQuery(messages) {
+  return messages.filter(
+    (message) => message.role === "user" || message.role === "assistant"
+  ).slice(-3).map((message) => message.content).filter(Boolean).join(" ");
+}
+function matchesSelector(tool2, selector, activeProfile) {
+  const normalized = selector.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "*" || normalized === "all") {
+    return true;
+  }
+  if (normalized === tool2.name.toLowerCase()) {
+    return true;
+  }
+  if (normalized.startsWith("group:")) {
+    return (tool2.group ?? "").toLowerCase() === normalized.slice(6);
+  }
+  if (normalized.startsWith("category:")) {
+    return (tool2.category ?? "").toLowerCase() === normalized.slice(9);
+  }
+  if (normalized.startsWith("profile:")) {
+    return (tool2.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized.slice(8));
+  }
+  if (activeProfile && normalized === activeProfile.toLowerCase()) {
+    return (tool2.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized);
+  }
+  return false;
+}
+function scoreTool(tool2, queryTokens, activeProfile) {
+  const haystack = [
+    tool2.name,
+    tool2.description,
+    tool2.category,
+    tool2.group,
+    ...tool2.profiles ?? [],
+    ...tool2.searchKeywords ?? []
+  ].filter(Boolean).join(" ").toLowerCase();
+  let score = tool2.deferLoading ? 0 : 2;
+  if (activeProfile && tool2.profiles?.includes(activeProfile)) {
+    score += 2;
+  }
+  for (const token of queryTokens) {
+    if (tool2.name.toLowerCase() === token) {
+      score += 6;
+    } else if (tool2.name.toLowerCase().includes(token)) {
+      score += 4;
+    } else if (haystack.includes(token)) {
+      score += 2;
+    }
+  }
+  return score;
+}
+function truncateText(text, maxChars, strategy, notice = TOOL_RESULT_TRUNCATION_NOTICE) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const bodyBudget = Math.max(1, maxChars - notice.length);
+  if (strategy === "head") {
+    return text.slice(0, bodyBudget) + notice;
+  }
+  if (strategy === "head-tail" || strategy === "smart") {
+    const tailLooksImportant = strategy === "smart" ? /\b(error|exception|failed|traceback|summary|result|done|complete)\b/i.test(
+      text.slice(-2e3)
+    ) : true;
+    if (tailLooksImportant && bodyBudget > 32) {
+      const tailBudget = Math.min(Math.floor(bodyBudget * 0.3), 4e3);
+      const headBudget = Math.max(1, bodyBudget - tailBudget - 32);
+      return text.slice(0, headBudget) + "\n\n[... omitted ...]\n\n" + text.slice(-tailBudget) + notice;
+    }
+  }
+  return text.slice(0, bodyBudget) + notice;
+}
+function isHistorySummaryMessage(message) {
+  return message.role === "system" && typeof message.content === "string" && message.content.startsWith(HISTORY_SUMMARY_HEADER);
+}
+function collectTopKeywords(messages) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "user") {
+      continue;
+    }
+    for (const token of tokenize(stringifyContent(message.content))) {
+      if (token.length < 3 || SUMMARY_STOP_WORDS.has(token)) {
+        continue;
+      }
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((left, right) => {
+    const countDiff = right[1] - left[1];
+    if (countDiff !== 0) {
+      return countDiff;
+    }
+    return left[0].localeCompare(right[0]);
+  }).slice(0, 5).map(([token]) => token);
+}
+function collectToolCallNames(messages) {
+  const toolCallNames = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "assistant" || !message.tool_calls?.length) {
+      continue;
+    }
+    for (const toolCall of message.tool_calls) {
+      const parsedToolCall = toolCall;
+      if (parsedToolCall.id && parsedToolCall.function?.name) {
+        toolCallNames.set(parsedToolCall.id, parsedToolCall.function.name);
+      }
+    }
+  }
+  return toolCallNames;
+}
+function compressSummaryContent(content, maxChars, fallbackBehavior) {
+  if (content.length <= maxChars) {
+    return content;
+  }
+  if (fallbackBehavior === "error") {
+    throw new Error("History summary exceeded configured continuity budget.");
+  }
+  if (fallbackBehavior === "statistical") {
+    const lines = content.split("\n");
+    const retained = lines.filter(
+      (line) => /^(Conversation summary|Stats:|- Messages compacted:|- User turns compacted:|- Assistant turns compacted:|- Tool results compacted:|- Latest user request before preserved window:|- Latest assistant response before preserved window:)/.test(
+        line
+      )
+    );
+    const statistical = retained.join("\n");
+    if (statistical.length <= maxChars) {
+      return statistical;
+    }
+  }
+  return truncateText(
+    content,
+    maxChars,
+    "head",
+    HISTORY_SUMMARY_COMPACTION_NOTICE
+  );
+}
+function buildHistorySummary(messages, summarization, maxChars = DEFAULT_SUMMARY_MAX_CHARS) {
+  if (messages.length === 0) {
+    return null;
+  }
+  if (summarization?.enabled === false) {
+    return null;
+  }
+  const previousSummaries = messages.filter(isHistorySummaryMessage);
+  const rawMessages = messages.filter(
+    (message) => !isHistorySummaryMessage(message)
+  );
+  const focusWindowSize = Math.max(
+    1,
+    summarization?.chunkSize ?? DEFAULT_SUMMARY_CHUNK_SIZE
+  );
+  const detailedThreshold = Math.max(
+    1,
+    summarization?.triggerAt ?? DEFAULT_SUMMARY_TRIGGER
+  );
+  const focusMessages = rawMessages.slice(-focusWindowSize);
+  const userMessages = rawMessages.filter((message) => message.role === "user");
+  const assistantMessages = rawMessages.filter(
+    (message) => message.role === "assistant"
+  );
+  const toolMessages = rawMessages.filter((message) => message.role === "tool");
+  const recentUser = abbreviateText(stringifyContent(userMessages.at(-1)?.content), 240) || "n/a";
+  const recentAssistant = abbreviateText(stringifyContent(assistantMessages.at(-1)?.content), 240) || "n/a";
+  const recentUserGoals = userMessages.slice(-3).map((message) => abbreviateText(stringifyContent(message.content), 180)).filter(Boolean);
+  const recentAssistantNotes = assistantMessages.map((message) => abbreviateText(stringifyContent(message.content), 180)).filter(Boolean).slice(-2);
+  const toolCallNames = collectToolCallNames(rawMessages);
+  const toolActivity = unique([
+    ...focusMessages.filter((message) => message.role === "assistant").flatMap(
+      (message) => (message.tool_calls ?? []).map((toolCall) => {
+        const parsedToolCall = toolCall;
+        return parsedToolCall.function?.name;
+      }).filter((name) => Boolean(name))
+    ),
+    ...toolMessages.slice(-2).map((message) => {
+      const toolName = message.tool_call_id ? toolCallNames.get(message.tool_call_id) : void 0;
+      const snippet = abbreviateText(stringifyContent(message.content), 120);
+      return toolName && snippet ? `${toolName}: ${snippet}` : toolName ?? snippet;
+    }).filter(Boolean)
+  ]).slice(-4);
+  const priorSummaryCarryForward = previousSummaries.map(
+    (message) => abbreviateText(
+      stringifyContent(message.content).replace(
+        `${HISTORY_SUMMARY_HEADER}
+`,
+        ""
+      ),
+      180
+    )
+  ).filter(Boolean).slice(-2);
+  const topKeywords = rawMessages.length >= detailedThreshold ? collectTopKeywords(
+    focusMessages.length > 0 ? focusMessages : rawMessages
+  ) : [];
+  const lines = [
+    HISTORY_SUMMARY_HEADER,
+    "Stats:",
+    `- Messages compacted: ${messages.length}`,
+    `- User turns compacted: ${userMessages.length}`,
+    `- Assistant turns compacted: ${assistantMessages.length}`,
+    `- Tool results compacted: ${toolMessages.length}`
+  ];
+  if (previousSummaries.length > 0) {
+    lines.push(`- Previous summaries merged: ${previousSummaries.length}`);
+  }
+  if (rawMessages.length > focusMessages.length) {
+    lines.push(
+      `- Older compacted messages outside the detailed window: ${rawMessages.length - focusMessages.length}`
+    );
+  }
+  if (topKeywords.length > 0) {
+    lines.push(`- Recurring user topics: ${topKeywords.join(", ")}`);
+  }
+  if (recentUser !== "n/a") {
+    lines.push(`- Latest user request before preserved window: ${recentUser}`);
+  }
+  if (recentAssistant !== "n/a") {
+    lines.push(
+      `- Latest assistant response before preserved window: ${recentAssistant}`
+    );
+  }
+  if (recentUserGoals.length > 0) {
+    lines.push("Carry forward user goals:");
+    for (const goal of recentUserGoals) {
+      lines.push(`- ${goal}`);
+    }
+  }
+  if (recentAssistantNotes.length > 0) {
+    lines.push("Carry forward assistant commitments:");
+    for (const note of recentAssistantNotes) {
+      lines.push(`- ${note}`);
+    }
+  }
+  if (toolActivity.length > 0) {
+    lines.push("Recent tool activity:");
+    for (const item of toolActivity) {
+      lines.push(`- ${item}`);
+    }
+  }
+  if (priorSummaryCarryForward.length > 0) {
+    lines.push("Earlier carried-forward context:");
+    for (const item of priorSummaryCarryForward) {
+      lines.push(`- ${item}`);
+    }
+  }
+  const content = compressSummaryContent(
+    lines.join("\n"),
+    maxChars,
+    summarization?.fallbackBehavior
+  );
+  return {
+    role: "system",
+    content
+  };
+}
+function buildToolDefinitions(selectedTools) {
+  if (selectedTools.length === 0) {
+    return void 0;
+  }
+  return selectedTools.map((tool2) => ({
+    name: tool2.name,
+    description: tool2.description,
+    category: tool2.category,
+    group: tool2.group,
+    deferLoading: tool2.deferLoading,
+    profiles: tool2.profiles,
+    searchKeywords: tool2.searchKeywords,
+    inputSchema: tool2.inputSchema
+  }));
+}
+function resolveTruncationConfig(params) {
+  const charsPerToken = params.config?.contextManagement?.tokenEstimation?.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
+  const contextWindowTokens = params.config?.contextBudget?.budget?.contextWindowTokens;
+  const globalConfig = params.config?.toolResultConfig?.truncation;
+  const perToolConfig = params.tool?.resultConfig?.truncation;
+  const merged = { ...globalConfig, ...perToolConfig };
+  const hardMaxChars = merged.hardMaxChars ?? (contextWindowTokens ? Math.floor(
+    contextWindowTokens * clampRatio(
+      merged.maxContextShare,
+      DEFAULT_MAX_TOOL_RESULT_CONTEXT_SHARE
+    ) * charsPerToken
+  ) : DEFAULT_TOOL_RESULT_HARD_MAX_CHARS);
+  return {
+    enabled: merged.enabled ?? true,
+    maxContextShare: clampRatio(
+      merged.maxContextShare,
+      DEFAULT_MAX_TOOL_RESULT_CONTEXT_SHARE
+    ),
+    hardMaxChars: Math.max(1, hardMaxChars),
+    minKeepChars: Math.max(
+      256,
+      merged.minKeepChars ?? DEFAULT_TOOL_RESULT_MIN_KEEP_CHARS
+    ),
+    strategy: merged.strategy ?? DEFAULT_TOOL_RESULT_STRATEGY,
+    preserveErrors: merged.preserveErrors ?? true
+  };
+}
+function buildToolResultContent(result, tool2, args) {
+  if (typeof result === "string") {
+    return result;
+  }
+  const typedResult = result ?? null;
   const responseMode = typedResult?._aiResponseMode ?? tool2?.aiResponseMode ?? "full";
   if (typedResult?._aiContent) {
     return JSON.stringify(typedResult._aiContent);
   }
   let aiContext = typedResult?._aiContext;
   if (!aiContext && tool2?.aiContext) {
-    aiContext = typeof tool2.aiContext === "function" ? tool2.aiContext(typedResult, args ?? {}) : tool2.aiContext;
+    aiContext = typeof tool2.aiContext === "function" ? tool2.aiContext(
+      typedResult ?? { success: true },
+      args ?? {}
+    ) : tool2.aiContext;
   }
   switch (responseMode) {
     case "none":
@@ -561,7 +985,7 @@ function buildToolResultContentForAI(result, tool2, args) {
     case "brief":
       return aiContext ?? "[Tool executed successfully]";
     case "full":
-    default:
+    default: {
       if (aiContext) {
         const {
           _aiResponseMode,
@@ -579,18 +1003,526 @@ Full data: ${JSON.stringify(dataOnly)}`;
         return JSON.stringify(dataOnly);
       }
       return JSON.stringify(result);
+    }
+  }
+}
+function buildToolResultContentForPrompt(result, tool2, args, config) {
+  const text = buildToolResultContent(result, tool2, args);
+  const truncation = resolveTruncationConfig({ tool: tool2, config });
+  if (!truncation.enabled) {
+    return text;
+  }
+  if (truncation.preserveErrors && typeof result === "object" && result !== null && "error" in result && typeof result.error === "string") {
+    return text;
+  }
+  const maxChars = Math.max(truncation.minKeepChars, truncation.hardMaxChars);
+  return truncateText(text, maxChars, truncation.strategy);
+}
+function sliceHistoryToMaxMessages(params) {
+  const { historyMessages, maxMessages, pruneStrategy, summarization } = params;
+  if (!maxMessages || historyMessages.length <= maxMessages) {
+    return historyMessages;
+  }
+  const dropped = historyMessages.slice(
+    0,
+    historyMessages.length - maxMessages
+  );
+  const kept = historyMessages.slice(-maxMessages);
+  if (pruneStrategy === "summarize") {
+    const summary = buildHistorySummary(dropped, summarization);
+    return summary ? [summary, ...kept] : kept;
+  }
+  return kept;
+}
+function compactHistoryToTokenBudget(params) {
+  const {
+    maxTokens,
+    preserveRecent,
+    charsPerToken,
+    pruneStrategy,
+    summarization
+  } = params;
+  let historyMessages = params.historyMessages;
+  if (!maxTokens) {
+    return historyMessages;
+  }
+  const getHistoryTokens = () => historyMessages.reduce(
+    (sum, message) => sum + estimateMessageTokens(message, charsPerToken),
+    0
+  );
+  while (historyMessages.length > 1 && getHistoryTokens() > maxTokens) {
+    const prunableCount = Math.max(0, historyMessages.length - preserveRecent);
+    if (prunableCount <= 0) {
+      const firstMessage = historyMessages[0];
+      if (isHistorySummaryMessage(firstMessage) && typeof firstMessage.content === "string") {
+        const compactedSummary = compressSummaryContent(
+          firstMessage.content,
+          Math.max(400, Math.floor(maxTokens * charsPerToken * 0.25)),
+          summarization?.fallbackBehavior
+        );
+        if (compactedSummary !== firstMessage.content) {
+          historyMessages = [
+            { ...firstMessage, content: compactedSummary },
+            ...historyMessages.slice(1)
+          ];
+          continue;
+        }
+      }
+      historyMessages = historyMessages.slice(1);
+      continue;
+    }
+    const pruned = historyMessages.slice(0, prunableCount);
+    const kept = historyMessages.slice(prunableCount);
+    if (pruneStrategy === "summarize") {
+      const summary = buildHistorySummary(
+        pruned,
+        summarization,
+        Math.max(500, Math.floor(maxTokens * charsPerToken * 0.35))
+      );
+      historyMessages = summary ? [summary, ...kept] : kept;
+    } else {
+      historyMessages = kept;
+    }
+  }
+  return historyMessages;
+}
+function compactToolResultsToBudget(params) {
+  let toolResultMessages = params.toolResultMessages;
+  if (!params.maxTokens) {
+    return toolResultMessages;
+  }
+  const getToolResultTokens = () => toolResultMessages.reduce(
+    (sum, message) => sum + estimateMessageTokens(message, params.charsPerToken),
+    0
+  );
+  while (toolResultMessages.length > 0 && getToolResultTokens() > params.maxTokens) {
+    const index = toolResultMessages.findIndex(
+      (message) => message.content !== TOOL_RESULT_COMPACTION_NOTICE
+    );
+    if (index === -1) {
+      break;
+    }
+    toolResultMessages = toolResultMessages.map(
+      (message, currentIndex) => currentIndex === index ? { ...message, content: TOOL_RESULT_COMPACTION_NOTICE } : message
+    );
+  }
+  return toolResultMessages;
+}
+function fitToolsToBudget(params) {
+  let tools = params.tools;
+  if (!tools?.length || !params.maxTokens) {
+    return tools;
   }
+  const getToolTokens = () => tools.reduce(
+    (sum, tool2) => sum + estimateToolTokens(tool2, params.charsPerToken),
+    0
+  );
+  while (tools.length > 0 && getToolTokens() > params.maxTokens) {
+    tools = tools.slice(0, -1);
+  }
+  return tools;
+}
+function truncateSystemPromptToBudget(params) {
+  const { systemPrompt, maxTokens, charsPerToken } = params;
+  if (!systemPrompt || !maxTokens) {
+    return systemPrompt;
+  }
+  const maxChars = maxTokens * charsPerToken;
+  if (systemPrompt.length <= maxChars) {
+    return systemPrompt;
+  }
+  return truncateText(
+    systemPrompt,
+    maxChars,
+    "head",
+    SYSTEM_PROMPT_TRUNCATION_NOTICE
+  );
+}
+function calculateBuckets(params) {
+  const systemPromptTokens = estimateTokens(
+    params.systemPrompt ?? "",
+    params.charsPerToken
+  );
+  const historyTokens = params.historyMessages.reduce(
+    (sum, message) => sum + estimateMessageTokens(message, params.charsPerToken),
+    0
+  );
+  const toolResultsTokens = params.toolResultMessages.reduce(
+    (sum, message) => sum + estimateMessageTokens(message, params.charsPerToken),
+    0
+  );
+  const toolDefinitionTokens = (params.requestTools ?? []).reduce(
+    (sum, tool2) => sum + estimateToolTokens(tool2, params.charsPerToken),
+    0
+  );
+  const total = systemPromptTokens + historyTokens + toolResultsTokens + toolDefinitionTokens;
+  const budget = Number.isFinite(params.availableBudget) ? params.availableBudget : total;
+  const toPart = (tokens) => ({
+    tokens,
+    percent: budget > 0 ? Number((tokens / budget * 100).toFixed(2)) : 0
+  });
+  return {
+    total: toPart(total),
+    breakdown: {
+      systemPrompt: toPart(systemPromptTokens),
+      history: toPart(historyTokens),
+      toolResults: toPart(toolResultsTokens),
+      tools: toPart(toolDefinitionTokens)
+    },
+    budget: {
+      available: budget,
+      remaining: Math.max(0, budget - total)
+    },
+    warnings: unique(params.warnings)
+  };
+}
+function mergeBucketsInOriginalOrder(params) {
+  const historyQueue = [...params.historyMessages];
+  const toolQueue = [...params.toolResultMessages];
+  return params.transformedMessages.flatMap((message) => {
+    if (message.role === "tool") {
+      const nextTool = toolQueue.shift();
+      return nextTool ? [nextTool] : [];
+    }
+    const nextHistory = historyQueue.shift();
+    return nextHistory ? [nextHistory] : [];
+  });
 }
+var ChatContextOptimizer = class {
+  constructor(config) {
+    this.lastContextUsage = null;
+    this.config = config;
+    this.activeProfile = config?.toolProfiles?.defaultProfile;
+  }
+  updateConfig(config) {
+    this.config = config;
+    if (!this.activeProfile) {
+      this.activeProfile = config?.toolProfiles?.defaultProfile;
+    }
+  }
+  setActiveProfile(profile) {
+    this.activeProfile = profile?.trim() || void 0;
+  }
+  getContextUsage() {
+    return this.lastContextUsage;
+  }
+  prepare(params) {
+    const charsPerToken = this.config?.contextManagement?.tokenEstimation?.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
+    const safetyMargin = this.config?.contextManagement?.tokenEstimation?.safetyMargin ?? DEFAULT_SAFETY_MARGIN;
+    const warnings = [];
+    const contextManagement = this.config?.contextManagement;
+    const contextBudget = this.config?.contextBudget;
+    const allTools = params.tools ?? [];
+    const selectedTools = this.selectTools(allTools, params.messages);
+    const transformedMessages = this.transformMessages(
+      params.messages,
+      allTools
+    );
+    const preserveRecent = contextManagement?.summarization?.preserveRecent ?? DEFAULT_RECENT_HISTORY_PRESERVE;
+    let buckets = {
+      systemPrompt: params.systemPrompt,
+      transformedMessages,
+      historyMessages: transformedMessages.filter(
+        (message) => message.role !== "tool"
+      ),
+      toolResultMessages: transformedMessages.filter(
+        (message) => message.role === "tool"
+      ),
+      requestTools: buildToolDefinitions(selectedTools)
+    };
+    if (contextManagement?.enabled) {
+      buckets.historyMessages = sliceHistoryToMaxMessages({
+        historyMessages: buckets.historyMessages,
+        maxMessages: contextManagement.history?.maxMessages,
+        pruneStrategy: contextManagement.history?.pruneStrategy,
+        summarization: contextManagement?.summarization
+      });
+    }
+    const budgetConfig = contextBudget?.budget;
+    const contextWindowTokens = budgetConfig?.contextWindowTokens;
+    const inputHeadroomRatio = clampRatio(
+      budgetConfig?.inputHeadroomRatio,
+      DEFAULT_INPUT_HEADROOM_RATIO
+    );
+    const availableBudget = contextWindowTokens ? Math.max(1, Math.floor(contextWindowTokens * inputHeadroomRatio)) : Number.POSITIVE_INFINITY;
+    const sharedBudget = Number.isFinite(availableBudget) ? availableBudget : void 0;
+    const systemPromptBudget = sharedBudget ? Math.max(
+      1,
+      Math.floor(
+        sharedBudget * clampRatio(
+          budgetConfig?.systemPromptShare,
+          DEFAULT_SYSTEM_PROMPT_SHARE
+        )
+      )
+    ) : void 0;
+    const historyBudgetByShare = sharedBudget ? Math.max(
+      1,
+      Math.floor(
+        sharedBudget * clampRatio(budgetConfig?.historyShare, DEFAULT_HISTORY_SHARE)
+      )
+    ) : void 0;
+    const historyBudgetByConfig = contextManagement?.enabled && contextManagement.history?.maxTokens ? Math.floor(contextManagement.history.maxTokens / safetyMargin) : void 0;
+    const historyBudget = historyBudgetByShare && historyBudgetByConfig ? Math.min(historyBudgetByShare, historyBudgetByConfig) : historyBudgetByShare ?? historyBudgetByConfig;
+    const toolResultsBudget = sharedBudget ? Math.max(
+      1,
+      Math.floor(
+        sharedBudget * clampRatio(
+          budgetConfig?.toolResultsShare,
+          DEFAULT_TOOL_RESULTS_SHARE
+        )
+      )
+    ) : void 0;
+    const toolDefinitionsBudget = sharedBudget ? Math.max(
+      1,
+      Math.floor(
+        sharedBudget * clampRatio(
+          budgetConfig?.toolDefinitionsShare,
+          DEFAULT_TOOL_DEFINITIONS_SHARE
+        )
+      )
+    ) : void 0;
+    if (contextBudget?.enabled) {
+      buckets.systemPrompt = truncateSystemPromptToBudget({
+        systemPrompt: buckets.systemPrompt,
+        maxTokens: systemPromptBudget,
+        charsPerToken
+      });
+    }
+    buckets.historyMessages = compactHistoryToTokenBudget({
+      historyMessages: buckets.historyMessages,
+      maxTokens: historyBudget,
+      preserveRecent,
+      charsPerToken,
+      pruneStrategy: contextManagement?.history?.pruneStrategy,
+      summarization: contextManagement?.summarization
+    });
+    buckets.toolResultMessages = compactToolResultsToBudget({
+      toolResultMessages: buckets.toolResultMessages,
+      maxTokens: toolResultsBudget,
+      charsPerToken
+    });
+    buckets.requestTools = fitToolsToBudget({
+      tools: buckets.requestTools,
+      maxTokens: toolDefinitionsBudget,
+      charsPerToken
+    });
+    let usage = calculateBuckets({
+      ...buckets,
+      charsPerToken,
+      availableBudget,
+      warnings
+    });
+    if (Number.isFinite(availableBudget) && usage.total.tokens > availableBudget) {
+      buckets.toolResultMessages = compactToolResultsToBudget({
+        toolResultMessages: buckets.toolResultMessages,
+        maxTokens: Math.max(
+          1,
+          usage.breakdown.toolResults.tokens - usage.total.tokens + availableBudget
+        ),
+        charsPerToken
+      });
+      usage = calculateBuckets({
+        ...buckets,
+        charsPerToken,
+        availableBudget,
+        warnings
+      });
+      if (usage.total.tokens > availableBudget) {
+        const overflow = usage.total.tokens - availableBudget;
+        buckets.historyMessages = compactHistoryToTokenBudget({
+          historyMessages: buckets.historyMessages,
+          maxTokens: Math.max(1, usage.breakdown.history.tokens - overflow),
+          preserveRecent,
+          charsPerToken,
+          pruneStrategy: contextManagement?.history?.pruneStrategy
+        });
+        usage = calculateBuckets({
+          ...buckets,
+          charsPerToken,
+          availableBudget,
+          warnings
+        });
+      }
+      if (usage.total.tokens > availableBudget) {
+        buckets.requestTools = fitToolsToBudget({
+          tools: buckets.requestTools,
+          maxTokens: Math.max(
+            1,
+            usage.breakdown.tools.tokens - (usage.total.tokens - availableBudget)
+          ),
+          charsPerToken
+        });
+        usage = calculateBuckets({
+          ...buckets,
+          charsPerToken,
+          availableBudget,
+          warnings
+        });
+      }
+    }
+    if (Number.isFinite(availableBudget) && usage.total.tokens > availableBudget) {
+      warnings.push(
+        `Prompt budget exceeded: using ${usage.total.tokens} tokens of ${availableBudget}.`
+      );
+      usage = {
+        ...usage,
+        warnings: unique(warnings)
+      };
+      if (contextBudget?.enforcement?.mode === "error") {
+        throw new Error(warnings[warnings.length - 1]);
+      }
+      contextBudget?.enforcement?.onBudgetExceeded?.(usage);
+    } else {
+      usage = {
+        ...usage,
+        warnings: unique(warnings)
+      };
+    }
+    contextBudget?.monitoring?.onUsageUpdate?.(usage);
+    this.lastContextUsage = usage;
+    return {
+      messages: mergeBucketsInOriginalOrder(buckets),
+      tools: buckets.requestTools,
+      contextUsage: usage,
+      warnings: usage.warnings
+    };
+  }
+  selectTools(tools, messages) {
+    if (!tools.length) {
+      return [];
+    }
+    const available = tools.filter((tool2) => tool2.available !== false);
+    const profileConfig = this.config?.toolProfiles;
+    if (!profileConfig?.enabled) {
+      return available;
+    }
+    const activeProfile = this.activeProfile ?? profileConfig.defaultProfile;
+    const includeUnprofiled = profileConfig.includeUnprofiled ?? true;
+    const profile = activeProfile ? profileConfig.profiles?.[activeProfile] : void 0;
+    let filtered = available;
+    if (profile?.include?.length) {
+      filtered = filtered.filter(
+        (tool2) => profile.include.some(
+          (selector) => matchesSelector(tool2, selector, activeProfile)
+        ) || !!activeProfile && tool2.profiles?.includes(activeProfile)
+      );
+    } else if (activeProfile) {
+      filtered = filtered.filter((tool2) => {
+        if (tool2.profiles?.length) {
+          return tool2.profiles.includes(activeProfile);
+        }
+        return includeUnprofiled;
+      });
+    }
+    if (profile?.exclude?.length) {
+      filtered = filtered.filter(
+        (tool2) => !profile.exclude.some(
+          (selector) => matchesSelector(tool2, selector, activeProfile)
+        )
+      );
+    }
+    if (!profileConfig.dynamicSelection?.enabled) {
+      return filtered;
+    }
+    const maxTools = Math.max(
+      1,
+      Math.min(
+        profileConfig.dynamicSelection.maxTools ?? filtered.length,
+        filtered.length
+      )
+    );
+    const queryTokens = tokenize(buildToolQuery(messages));
+    return [...filtered].sort((left, right) => {
+      const scoreDiff = scoreTool(right, queryTokens, activeProfile) - scoreTool(left, queryTokens, activeProfile);
+      if (scoreDiff !== 0) {
+        return scoreDiff;
+      }
+      return left.name.localeCompare(right.name);
+    }).slice(0, maxTools);
+  }
+  transformMessages(messages, allTools) {
+    const toolCallMap = /* @__PURE__ */ new Map();
+    for (const message of messages) {
+      if (message.role !== "assistant" || !message.toolCalls?.length) {
+        continue;
+      }
+      for (const toolCall of message.toolCalls) {
+        try {
+          toolCallMap.set(toolCall.id, {
+            toolName: toolCall.function.name,
+            args: JSON.parse(toolCall.function.arguments)
+          });
+        } catch {
+          toolCallMap.set(toolCall.id, {
+            toolName: toolCall.function.name,
+            args: {}
+          });
+        }
+      }
+    }
+    const toolDefMap = new Map(
+      allTools.map((tool2) => [tool2.name, tool2])
+    );
+    return messages.map((message) => {
+      if (message.role !== "tool") {
+        return {
+          role: message.role,
+          content: message.content,
+          tool_calls: message.toolCalls,
+          tool_call_id: message.toolCallId,
+          attachments: message.attachments
+        };
+      }
+      const toolCall = message.toolCallId ? toolCallMap.get(message.toolCallId) : void 0;
+      const tool2 = toolCall ? toolDefMap.get(toolCall.toolName) : void 0;
+      let content = message.content;
+      try {
+        const parsed = JSON.parse(message.content);
+        content = buildToolResultContentForPrompt(
+          parsed,
+          tool2,
+          toolCall?.args ?? {},
+          this.config
+        );
+      } catch {
+        content = buildToolResultContentForPrompt(
+          message.content,
+          tool2,
+          toolCall?.args ?? {},
+          this.config
+        );
+      }
+      return {
+        role: message.role,
+        content,
+        tool_call_id: message.toolCallId
+      };
+    });
+  }
+};
+
+// src/chat/classes/AbstractChat.ts
 var AbstractChat = class {
   constructor(init) {
+    this.lastContextUsage = null;
     // Event handlers
     this.eventHandlers = /* @__PURE__ */ new Map();
     // Current streaming state
     this.streamState = null;
+    /**
+     * Inline skills from the client (sent on every request for server to merge)
+     */
+    this.inlineSkills = [];
     /**
      * Dynamic context from useAIContext hook
      */
     this.dynamicContext = "";
+    /**
+     * Optional transform applied to messages just before building the HTTP request.
+     * Used by the message-history / compaction system to send a pruned message list
+     * without mutating the in-memory store (which keeps the full history for display).
+     */
+    this.requestMessageTransform = null;
     this._isDisposed = false;
     this.config = {
       runtimeUrl: init.runtimeUrl,
@@ -600,7 +1532,8 @@ var AbstractChat = class {
       headers: init.headers,
       body: init.body,
       threadId: init.threadId,
-      debug: init.debug
+      debug: init.debug,
+      optimization: init.optimization
     };
     this.state = init.state ?? new SimpleChatState();
     this.transport = init.transport ?? new HttpTransport({
@@ -610,6 +1543,7 @@ var AbstractChat = class {
       streaming: init.streaming ?? true
     });
     this.callbacks = init.callbacks ?? {};
+    this.optimizer = new ChatContextOptimizer(init.optimization);
     if (init.initialMessages?.length) {
       this.state.setMessages(init.initialMessages);
     }
@@ -641,20 +1575,42 @@ var AbstractChat = class {
   /**
    * Send a message
    * Returns false if a request is already in progress
+   *
+   * @param content - Message content
+   * @param attachments - Optional attachments
+   * @param options - Optional branching options
+   * @param options.editMessageId - Edit flow: new message branches from the
+   *   same parent as this message ID, creating a parallel conversation path
    */
-  async sendMessage(content, attachments) {
+  async sendMessage(content, attachments, options) {
     if (this.isBusy) {
       this.debug("sendMessage", "Blocked - request already in progress");
       return false;
     }
-    this.debug("sendMessage", { content, attachments });
+    this.debug("sendMessage", { content, attachments, options });
     try {
       this.resolveUnresolvedToolCalls();
-      const userMessage = createUserMessage(content, attachments);
+      let newParentId;
+      const visibleMessages = this.state.messages;
+      if (options?.editMessageId && this.state.setCurrentLeaf) {
+        const allMessages = this.state.getAllMessages?.() ?? this.state.messages;
+        const target = allMessages.find((m) => m.id === options.editMessageId);
+        if (target && target.parentId !== void 0) {
+          newParentId = target.parentId;
+          this.state.setCurrentLeaf(
+            typeof target.parentId === "string" ? target.parentId : null
+          );
+        }
+      } else if (visibleMessages.length > 0) {
+        newParentId = visibleMessages[visibleMessages.length - 1].id;
+      }
+      const userMessage = createUserMessage(content, attachments, {
+        parentId: newParentId
+      });
       this.state.pushMessage(userMessage);
       this.state.status = "submitted";
       this.state.error = void 0;
-      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onMessagesChange?.(this._allMessages());
       this.callbacks.onStatusChange?.("submitted");
       await Promise.resolve();
       await this.processRequest();
@@ -704,7 +1660,7 @@ var AbstractChat = class {
         };
         this.state.pushMessage(toolMessage);
       }
-      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onMessagesChange?.(this._allMessages());
     }
   }
   /**
@@ -758,9 +1714,9 @@ var AbstractChat = class {
         this.state.pushMessage(userMessage);
       }
       this.state.status = "submitted";
-      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onMessagesChange?.(this._allMessages());
       this.callbacks.onStatusChange?.("submitted");
-      await Promise.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 0));
       await this.processRequest();
     } catch (error) {
       this.handleError(error);
@@ -789,30 +1745,58 @@ var AbstractChat = class {
     this.callbacks.onMessagesChange?.(messages);
   }
   /**
-   * Regenerate last response
+   * Regenerate last response.
+   *
+   * Branch-aware: when the state supports branching (setCurrentLeaf is available),
+   * regenerate creates a new sibling response instead of destroying the original.
+   * The old response is preserved and navigable via switchBranch().
+   *
+   * Legacy fallback: when branching is not available, uses old slice() behavior.
    */
   async regenerate(messageId) {
+    if (this.isBusy) return;
     const messages = this.state.messages;
-    let targetIndex = messages.length - 1;
+    let targetMessage;
     if (messageId) {
-      targetIndex = messages.findIndex((m) => m.id === messageId);
+      targetMessage = messages.find((m) => m.id === messageId);
+      if (!targetMessage) {
+        targetMessage = this.state.getAllMessages?.().find((m) => m.id === messageId);
+      }
     } else {
       for (let i = messages.length - 1; i >= 0; i--) {
         if (messages[i].role === "assistant") {
-          targetIndex = i;
+          targetMessage = messages[i];
           break;
         }
       }
     }
+    if (!targetMessage) return;
+    if (targetMessage.parentId !== void 0 && this.state.setCurrentLeaf) {
+      this.state.setCurrentLeaf(targetMessage.parentId ?? null);
+      this.callbacks.onMessagesChange?.(this._allMessages());
+      this.state.status = "submitted";
+      await Promise.resolve();
+      await this.processRequest();
+      return;
+    }
+    const targetIndex = messages.indexOf(targetMessage);
     if (targetIndex > 0) {
       this.state.setMessages(messages.slice(0, targetIndex));
-      this.callbacks.onMessagesChange?.(this.state.messages);
+      this.callbacks.onMessagesChange?.(this._allMessages());
       await this.processRequest();
     }
   }
   // ============================================
   // Event Handling
   // ============================================
+  /**
+   * Returns all messages across all branches when the state supports it
+   * (branch-aware), otherwise returns the visible path.
+   * Use this whenever firing onMessagesChange so inactive branches are not lost.
+   */
+  _allMessages() {
+    return this.state.getAllMessages?.() ?? this.state.messages;
+  }
   /**
    * Subscribe to events
    */
@@ -844,10 +1828,32 @@ var AbstractChat = class {
    */
   async processRequest() {
     const request = this.buildRequest();
+    let preCreatedMessageId;
+    if (this.config.streaming !== false) {
+      const visibleMessages = this.state.messages;
+      const currentLeafId = visibleMessages.length > 0 ? visibleMessages[visibleMessages.length - 1].id : void 0;
+      const preMsg = createEmptyAssistantMessage(void 0, {
+        parentId: currentLeafId
+      });
+      this.state.pushMessage(preMsg);
+      this.callbacks.onMessagesChange?.(this._allMessages());
+      preCreatedMessageId = preMsg.id;
+    }
     const response = await this.transport.send(request);
     if (this.isAsyncIterable(response)) {
-      await this.handleStreamResponse(response);
+      await this.handleStreamResponse(response, preCreatedMessageId);
     } else {
+      if (preCreatedMessageId) {
+        const id = preCreatedMessageId;
+        const visibleMsgs = this.state.messages;
+        const placeholderIdx = visibleMsgs.findIndex((m) => m.id === id);
+        const intendedLeafId = placeholderIdx > 0 ? visibleMsgs[placeholderIdx - 1].id : null;
+        const allMsgs = this.state.getAllMessages?.() ?? this.state.messages;
+        this.state.setMessages(allMsgs.filter((m) => m.id !== id));
+        if (intendedLeafId && this.state.setCurrentLeaf) {
+          this.state.setCurrentLeaf(intendedLeafId);
+        }
+      }
       this.handleJsonResponse(response);
     }
   }
@@ -858,30 +1864,60 @@ var AbstractChat = class {
     this.config.tools = tools;
   }
   /**
-   * Set dynamic context (appended to system prompt)
+   * Update prompt/tool optimization behavior.
    */
-  setContext(context) {
-    this.dynamicContext = context;
-    this.debug("Context updated", { length: context.length });
+  setOptimizationConfig(config) {
+    this.config.optimization = config;
+    this.optimizer.updateConfig(config);
   }
   /**
-   * Set system prompt dynamically
-   * This allows updating the system prompt after initialization
+   * Select the active tool profile for future requests.
    */
-  setSystemPrompt(prompt) {
-    this.config.systemPrompt = prompt;
-    this.debug("System prompt updated", { length: prompt.length });
+  setToolProfile(profile) {
+    this.optimizer.setActiveProfile(profile);
   }
   /**
-   * Set headers configuration
-   * Can be static headers or a getter function for dynamic resolution
+   * Get the most recent prompt context usage snapshot.
    */
-  setHeaders(headers) {
-    this.config.headers = headers;
+  getContextUsage() {
+    return this.lastContextUsage;
+  }
+  /**
+   * Set inline skills (called by SkillProvider via React layer)
+   */
+  setInlineSkills(skills) {
+    this.inlineSkills = skills;
+    this.debug("Inline skills updated", { count: skills.length });
+  }
+  /**
+   * Set (or clear) the per-request message transform.
+   * Pass null to disable.
+   */
+  setRequestMessageTransform(fn) {
+    this.requestMessageTransform = fn;
+  }
+  /**
+   * Set dynamic context (appended to system prompt)
+   */
+  setContext(context) {
+    this.dynamicContext = context;
+  }
+  /**
+   * Set system prompt dynamically
+   * This allows updating the system prompt after initialization
+   */
+  setSystemPrompt(prompt) {
+    this.config.systemPrompt = prompt;
+  }
+  /**
+   * Set headers configuration
+   * Can be static headers or a getter function for dynamic resolution
+   */
+  setHeaders(headers) {
+    this.config.headers = headers;
     if (this.transport.setHeaders && headers !== void 0) {
       this.transport.setHeaders(headers);
     }
-    this.debug("Headers config updated");
   }
   /**
    * Set URL configuration
@@ -892,7 +1928,6 @@ var AbstractChat = class {
     if (this.transport.setUrl) {
       this.transport.setUrl(url);
     }
-    this.debug("URL config updated");
   }
   /**
    * Set body configuration
@@ -903,110 +1938,88 @@ var AbstractChat = class {
     if (this.transport.setBody && body !== void 0) {
       this.transport.setBody(body);
     }
-    this.debug("Body config updated");
   }
   /**
    * Build the request payload
    */
   buildRequest() {
-    const tools = this.config.tools?.filter((tool2) => tool2.available !== false).map((tool2) => ({
-      name: tool2.name,
-      description: tool2.description,
-      inputSchema: tool2.inputSchema
-    }));
-    const toolCallMap = /* @__PURE__ */ new Map();
-    for (const msg of this.state.messages) {
-      if (msg.role === "assistant" && msg.toolCalls) {
-        for (const tc of msg.toolCalls) {
-          try {
-            const args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
-            toolCallMap.set(tc.id, { toolName: tc.function.name, args });
-          } catch {
-            toolCallMap.set(tc.id, { toolName: tc.function.name, args: {} });
-          }
-        }
-      }
-    }
-    const toolDefMap = /* @__PURE__ */ new Map();
-    if (this.config.tools) {
-      for (const tool2 of this.config.tools) {
-        toolDefMap.set(tool2.name, {
-          name: tool2.name,
-          aiResponseMode: tool2.aiResponseMode,
-          aiContext: tool2.aiContext
-        });
-      }
-    }
-    return {
-      messages: this.state.messages.map((m) => {
-        if (m.role === "tool" && m.content && m.toolCallId) {
-          try {
-            const fullResult = JSON.parse(m.content);
-            const toolCallInfo = toolCallMap.get(m.toolCallId);
-            const toolDef = toolCallInfo ? toolDefMap.get(toolCallInfo.toolName) : void 0;
-            const toolArgs = toolCallInfo?.args;
-            const transformedContent = buildToolResultContentForAI(
-              fullResult,
-              toolDef,
-              toolArgs
-            );
-            return {
-              role: m.role,
-              content: transformedContent,
-              tool_call_id: m.toolCallId
-            };
-          } catch (e) {
-            this.debug("Failed to parse tool message JSON", {
-              content: m.content?.slice(0, 100),
-              error: e instanceof Error ? e.message : String(e)
-            });
-            return {
-              role: m.role,
-              content: m.content,
-              tool_call_id: m.toolCallId
-            };
-          }
-        }
-        return {
-          role: m.role,
-          content: m.content,
-          tool_calls: m.toolCalls,
-          tool_call_id: m.toolCallId,
-          attachments: m.attachments
-        };
-      }),
-      threadId: this.config.threadId,
-      systemPrompt: this.dynamicContext ? `${this.config.systemPrompt || ""}
+    const systemPrompt = this.dynamicContext ? `${this.config.systemPrompt || ""}
 
 ## Current App Context:
-${this.dynamicContext}`.trim() : this.config.systemPrompt,
+${this.dynamicContext}`.trim() : this.config.systemPrompt;
+    const rawMessages = this.requestMessageTransform ? this.requestMessageTransform(
+      this.state.messages
+    ) : this.state.messages;
+    const optimized = this.optimizer.prepare({
+      messages: rawMessages,
+      tools: this.config.tools,
+      systemPrompt
+    });
+    this.lastContextUsage = optimized.contextUsage;
+    this.callbacks.onContextUsageChange?.(optimized.contextUsage);
+    return {
+      messages: optimized.messages,
+      threadId: this.config.threadId,
+      systemPrompt,
       llm: this.config.llm,
-      tools: tools?.length ? tools : void 0
+      tools: this.config.tools?.length ? this.config.tools.map((tool2) => ({
+        name: tool2.name,
+        description: tool2.description,
+        category: tool2.category,
+        group: tool2.group,
+        deferLoading: tool2.deferLoading,
+        profiles: tool2.profiles,
+        searchKeywords: tool2.searchKeywords,
+        inputSchema: tool2.inputSchema
+      })) : void 0,
+      __skills: this.inlineSkills.length ? this.inlineSkills : void 0
     };
   }
   /**
    * Handle streaming response
    */
-  async handleStreamResponse(stream) {
+  async handleStreamResponse(stream, preCreatedMessageId) {
     this.state.status = "streaming";
     this.callbacks.onStatusChange?.("streaming");
-    const assistantMessage = createEmptyAssistantMessage();
-    this.state.pushMessage(assistantMessage);
+    let assistantMessage;
+    if (preCreatedMessageId) {
+      const existing = this.state.messages.find(
+        (m) => m.id === preCreatedMessageId
+      );
+      if (existing) {
+        assistantMessage = existing;
+      } else {
+        assistantMessage = createEmptyAssistantMessage();
+        this.state.pushMessage(assistantMessage);
+      }
+    } else {
+      assistantMessage = createEmptyAssistantMessage();
+      this.state.pushMessage(assistantMessage);
+    }
     this.streamState = createStreamState(assistantMessage.id);
     this.callbacks.onMessageStart?.(assistantMessage.id);
-    this.debug("handleStreamResponse", "Starting to process stream");
+    this.debugGroup("handleStreamResponse");
+    this.debug("Starting to process stream");
     let chunkCount = 0;
     let toolCallsEmitted = false;
+    let pendingClientToolCalls;
     for await (const chunk of stream) {
       chunkCount++;
-      this.debug("chunk", { count: chunkCount, type: chunk.type });
+      if (chunk.type !== "message:delta") {
+        this.debug("chunk", { count: chunkCount, type: chunk.type });
+      }
       if (chunk.type === "error") {
         const error = new Error(chunk.message || "Stream error");
         this.handleError(error);
         return;
       }
       if (chunk.type === "message:end" && this.streamState?.content) {
-        this.debug("message:end mid-stream - finalizing current turn");
+        this.debug("message:end mid-stream", {
+          messageId: this.streamState.messageId,
+          contentLength: this.streamState.content.length,
+          toolCallsInState: this.streamState.toolCalls?.length ?? 0,
+          chunkCount
+        });
         const turnMessage = streamStateToMessage(this.streamState);
         const toolCallsHidden = {};
         for (const [id, result] of this.streamState.toolResults) {
@@ -1022,7 +2035,11 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
         }
         this.state.updateMessageById(
           this.streamState.messageId,
-          () => turnMessage
+          (existing) => ({
+            ...turnMessage,
+            ...existing.parentId !== void 0 ? { parentId: existing.parentId } : {},
+            ...existing.childrenIds !== void 0 ? { childrenIds: existing.childrenIds } : {}
+          })
         );
         this.callbacks.onMessageFinish?.(turnMessage);
         this.streamState = null;
@@ -1037,6 +2054,93 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
         continue;
       }
       if (!this.streamState) {
+        if (chunk.type === "tool_calls") {
+          pendingClientToolCalls = chunk.toolCalls;
+          this.debug("tool_calls (post-message:end, stored as pending)", {
+            count: pendingClientToolCalls?.length,
+            ids: pendingClientToolCalls?.map((tc) => tc.id)
+          });
+          continue;
+        }
+        if (chunk.type === "done") {
+          this.debug("done (post-message:end)", {
+            hasPendingToolCalls: !!pendingClientToolCalls?.length,
+            pendingCount: pendingClientToolCalls?.length ?? 0,
+            doneMessagesCount: chunk.messages?.length ?? 0,
+            requiresAction: chunk.requiresAction,
+            toolCallsEmitted
+          });
+          if (chunk.messages?.length) {
+            const pendingIds = new Set(
+              (pendingClientToolCalls ?? []).filter((tc) => tc?.id).map((tc) => tc.id)
+            );
+            const messagesToInsert = [];
+            let clientAssistantToolCalls;
+            for (const msg of chunk.messages) {
+              if (msg.role === "assistant" && msg.tool_calls?.length && pendingIds.size > 0 && msg.tool_calls.every(
+                (tc) => pendingIds.has(tc?.id ?? "")
+              )) {
+                clientAssistantToolCalls = msg.tool_calls;
+                continue;
+              }
+              if (msg.role === "assistant" && !msg.tool_calls?.length) continue;
+              messagesToInsert.push({
+                id: generateMessageId(),
+                role: msg.role,
+                content: msg.content ?? "",
+                toolCalls: msg.tool_calls,
+                toolCallId: msg.tool_call_id,
+                createdAt: /* @__PURE__ */ new Date()
+              });
+            }
+            if (clientAssistantToolCalls) {
+              const currentMessages = this.state.messages;
+              for (let i = currentMessages.length - 1; i >= 0; i--) {
+                if (currentMessages[i].role === "assistant") {
+                  this.state.updateMessageById(
+                    currentMessages[i].id,
+                    (m) => ({
+                      ...m,
+                      toolCalls: clientAssistantToolCalls
+                    })
+                  );
+                  break;
+                }
+              }
+            }
+            if (messagesToInsert.length > 0) {
+              const currentMessages = this.state.messages;
+              let insertIdx = currentMessages.length;
+              for (let i = currentMessages.length - 1; i >= 0; i--) {
+                if (currentMessages[i].role === "assistant") {
+                  insertIdx = i;
+                  break;
+                }
+              }
+              this.state.setMessages([
+                ...currentMessages.slice(0, insertIdx),
+                ...messagesToInsert,
+                ...currentMessages.slice(insertIdx)
+              ]);
+            }
+          }
+          if (!toolCallsEmitted && pendingClientToolCalls?.length) {
+            toolCallsEmitted = true;
+            this.debug("emit toolCalls (post-message:end path)", {
+              count: pendingClientToolCalls.length,
+              names: pendingClientToolCalls.map(
+                (tc) => tc.function?.name ?? tc.name
+              )
+            });
+            this.emit("toolCalls", { toolCalls: pendingClientToolCalls });
+          } else {
+            this.debug("skip emit toolCalls (post-message:end path)", {
+              toolCallsEmitted,
+              hasPending: !!pendingClientToolCalls?.length
+            });
+          }
+          continue;
+        }
         this.debug("warning", "streamState is null, skipping chunk");
         continue;
       }
@@ -1072,22 +2176,38 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
       const updatedMessage = streamStateToMessage(this.streamState);
       this.state.updateMessageById(
         this.streamState.messageId,
-        () => updatedMessage
+        // Preserve parentId/childrenIds from the existing placeholder so the
+        // branch tree structure (activeChildMap) is not corrupted when
+        // setCurrentLeaf() walks up the chain later.
+        (existing) => ({
+          ...updatedMessage,
+          ...existing.parentId !== void 0 ? { parentId: existing.parentId } : {},
+          ...existing.childrenIds !== void 0 ? { childrenIds: existing.childrenIds } : {}
+        })
       );
       if (chunk.type === "message:delta") {
         this.callbacks.onMessageDelta?.(assistantMessage.id, chunk.content);
       }
-      if (requiresToolExecution(chunk) && !toolCallsEmitted) {
-        toolCallsEmitted = true;
-        this.debug("toolCalls", { toolCalls: updatedMessage.toolCalls });
-        this.emit("toolCalls", { toolCalls: updatedMessage.toolCalls });
-      }
       if (isStreamDone(chunk)) {
-        this.debug("streamDone", { chunk });
+        this.debug("streamDone", {
+          chunkType: chunk.type,
+          requiresAction: chunk.requiresAction,
+          doneMessagesCount: chunk.messages?.length ?? 0,
+          streamToolCallsCount: this.streamState?.toolCalls?.length ?? 0,
+          toolCallsEmitted,
+          chunkCount
+        });
         if (chunk.type === "done" && chunk.messages?.length) {
           this.debug("processDoneMessages", {
-            count: chunk.messages.length
+            count: chunk.messages.length,
+            roles: chunk.messages.map(
+              (m) => `${m.role}${m.tool_calls?.length ? `[${m.tool_calls.length}tc]` : ""}`
+            )
           });
+          const currentStreamToolCallIds = new Set(
+            this.streamState?.toolCalls?.map((toolCall) => toolCall.id) ?? []
+          );
+          const messagesToInsert = [];
           const toolCallsHidden = {};
           if (this.streamState?.toolResults) {
             for (const [id, result] of this.streamState.toolResults) {
@@ -1097,7 +2217,12 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
             }
           }
           for (const msg of chunk.messages) {
-            if (msg.role === "assistant") {
+            if (msg.role === "assistant" && !msg.tool_calls?.length) {
+              continue;
+            }
+            if (msg.role === "assistant" && msg.tool_calls?.length && msg.tool_calls.every(
+              (toolCall) => currentStreamToolCallIds.has(toolCall.id)
+            )) {
               continue;
             }
             let metadata;
@@ -1113,7 +2238,60 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
               createdAt: /* @__PURE__ */ new Date(),
               metadata
             };
-            this.state.pushMessage(message);
+            messagesToInsert.push(message);
+          }
+          if (messagesToInsert.length > 0) {
+            const currentMessages = this.state.messages;
+            const currentStreamIndex = this.streamState ? currentMessages.findIndex(
+              (message) => message.id === this.streamState.messageId
+            ) : -1;
+            if (currentStreamIndex === -1) {
+              this.state.setMessages([...currentMessages, ...messagesToInsert]);
+            } else {
+              this.state.setMessages([
+                ...currentMessages.slice(0, currentStreamIndex),
+                ...messagesToInsert,
+                ...currentMessages.slice(currentStreamIndex)
+              ]);
+            }
+          }
+          this.debug("requiresAction check", {
+            requiresAction: chunk.requiresAction,
+            toolCallsEmitted,
+            updatedMessageToolCallsCount: updatedMessage.toolCalls?.length ?? 0,
+            messagesToInsertCount: messagesToInsert.length
+          });
+          if (chunk.requiresAction && !toolCallsEmitted) {
+            let clientToolCalls = updatedMessage.toolCalls;
+            if (!clientToolCalls?.length && messagesToInsert.length > 0) {
+              for (let i = messagesToInsert.length - 1; i >= 0; i--) {
+                const m = messagesToInsert[i];
+                if (m.role === "assistant" && m.toolCalls?.length) {
+                  clientToolCalls = m.toolCalls;
+                  this.debug("clientToolCalls from messagesToInsert", {
+                    index: i,
+                    count: clientToolCalls?.length
+                  });
+                  break;
+                }
+              }
+            }
+            if (clientToolCalls?.length) {
+              toolCallsEmitted = true;
+              this.debug("emit toolCalls (normal done path)", {
+                count: clientToolCalls.length,
+                names: clientToolCalls.map((tc) => tc.function?.name ?? tc.name)
+              });
+              this.emit("toolCalls", { toolCalls: clientToolCalls });
+            } else {
+              this.debug("requiresAction=true but no clientToolCalls found", {
+                updatedMessageToolCalls: updatedMessage.toolCalls,
+                messagesToInsert: messagesToInsert.map((m) => ({
+                  role: m.role,
+                  hasToolCalls: !!m.toolCalls?.length
+                }))
+              });
+            }
           }
         }
         break;
@@ -1138,15 +2316,22 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
           toolCallsHidden
         };
       }
-      this.state.updateMessageById(
-        this.streamState.messageId,
-        () => finalMessage
-      );
+      this.state.updateMessageById(this.streamState.messageId, (existing) => ({
+        ...finalMessage,
+        ...existing.parentId !== void 0 ? { parentId: existing.parentId } : {},
+        ...existing.childrenIds !== void 0 ? { childrenIds: existing.childrenIds } : {}
+      }));
       if (!finalMessage.content && (!finalMessage.toolCalls || finalMessage.toolCalls.length === 0)) {
         this.debug("warning", "Empty response - no content and no tool calls");
       }
     }
-    this.callbacks.onMessagesChange?.(this.state.messages);
+    this.callbacks.onMessagesChange?.(this._allMessages());
+    this.debugGroupEnd();
+    this.debug("stream end", {
+      toolCallsEmitted,
+      totalChunks: chunkCount,
+      messagesInState: this.state.messages.length
+    });
     if (!toolCallsEmitted) {
       this.state.status = "ready";
       this.callbacks.onStatusChange?.("ready");
@@ -1167,6 +2352,7 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
         }
       }
     }
+    let currentParentId = this.state.messages.length > 0 ? this.state.messages[this.state.messages.length - 1].id : void 0;
     for (const msg of response.messages ?? []) {
       let metadata;
       if (msg.role === "assistant" && msg.tool_calls && toolCallHiddenMap.size > 0) {
@@ -1189,11 +2375,15 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
         // CRITICAL: Preserve toolCallId for tool messages (fixes Anthropic API errors)
         toolCallId: msg.tool_call_id,
         createdAt: /* @__PURE__ */ new Date(),
-        metadata
+        metadata,
+        // Preserve branch tree structure: each message is a child of the
+        // current leaf so the tree is not corrupted for non-streaming mode.
+        ...currentParentId !== void 0 ? { parentId: currentParentId } : {}
       };
       this.state.pushMessage(message);
+      currentParentId = message.id;
     }
-    this.callbacks.onMessagesChange?.(this.state.messages);
+    this.callbacks.onMessagesChange?.(this._allMessages());
     const hasToolCalls = response.requiresAction && this.state.messages.length > 0 && this.state.messages[this.state.messages.length - 1]?.toolCalls?.length;
     if (hasToolCalls) {
       const lastMessage = this.state.messages[this.state.messages.length - 1];
@@ -1216,14 +2406,25 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
     this.callbacks.onStatusChange?.("error");
     this.emit("error", { error });
   }
-  /**
-   * Debug logging
-   */
+  get log() {
+    if (!this._log) {
+      this._log = chunkI3SQUNTT_cjs.createLogger("streaming", () => this.config.debug ?? false);
+    }
+    return this._log;
+  }
   debug(action, data) {
-    if (this.config.debug) {
-      console.log(`[AbstractChat] ${action}`, data);
+    this.log(action, data);
+  }
+  debugGroup(label, collapsed = true) {
+    if (collapsed) {
+      this.log.groupCollapsed(label);
+    } else {
+      this.log.group(label);
     }
   }
+  debugGroupEnd() {
+    this.log.groupEnd();
+  }
   /**
    * Type guard for async iterable
    */
@@ -1434,19 +2635,18 @@ var AbstractAgentLoop = class {
     this._isCancelled = false;
     this._isProcessing = true;
     this.setIteration(this._iteration + 1);
-    const results = [];
-    for (const toolCall of toolCalls) {
-      if (this._isCancelled || this.abortController.signal.aborted) {
-        results.push({
-          toolCallId: toolCall.id,
-          success: false,
-          error: "Tool execution cancelled"
-        });
-        continue;
-      }
-      const result = await this.executeSingleTool(toolCall);
-      results.push(result);
-    }
+    const results = await Promise.all(
+      toolCalls.map((toolCall) => {
+        if (this._isCancelled || this.abortController.signal.aborted) {
+          return Promise.resolve({
+            toolCallId: toolCall.id,
+            success: false,
+            error: "Tool execution cancelled"
+          });
+        }
+        return this.executeSingleTool(toolCall);
+      })
+    );
     this._isProcessing = false;
     return results;
   }
@@ -1764,6 +2964,7 @@ var ChatWithTools = class {
       streaming: config.streaming,
       headers: config.headers,
       body: config.body,
+      optimization: config.optimization,
       threadId: config.threadId,
       debug: config.debug,
       initialMessages: config.initialMessages,
@@ -1778,6 +2979,7 @@ var ChatWithTools = class {
         onMessageFinish: callbacks.onMessageFinish,
         onToolCalls: callbacks.onToolCalls,
         onFinish: callbacks.onFinish,
+        onContextUsageChange: callbacks.onContextUsageChange,
         // Server-side tool callbacks - track in agentLoop for UI display
         // IMPORTANT: Only track tools that are NOT registered client-side
         // Client-side tools are tracked via executeToolCalls() path
@@ -1945,14 +3147,17 @@ var ChatWithTools = class {
   /**
    * Send a message
    * Returns false if a request is already in progress
+   *
+   * @param options.editMessageId - Edit flow: new message branches from the
+   *   same parent as this message ID
    */
-  async sendMessage(content, attachments) {
+  async sendMessage(content, attachments, options) {
     if (this.isLoading) {
       this.debug("sendMessage blocked - request already in progress");
       return false;
     }
     this.agentLoop.resetIterations();
-    return await this.chat.sendMessage(content, attachments);
+    return await this.chat.sendMessage(content, attachments, options);
   }
   /**
    * Stop generation and cancel any running tools
@@ -1987,6 +3192,25 @@ var ChatWithTools = class {
   setTools(tools) {
     this.chat.setTools(tools);
   }
+  /**
+   * Update prompt/tool optimization controls.
+   */
+  setOptimizationConfig(config) {
+    this.config.optimization = config;
+    this.chat.setOptimizationConfig(config);
+  }
+  /**
+   * Set the active tool profile used for request-time tool selection.
+   */
+  setToolProfile(profile) {
+    this.chat.setToolProfile(profile);
+  }
+  /**
+   * Get the most recent prompt context usage snapshot.
+   */
+  getContextUsage() {
+    return this.chat.getContextUsage();
+  }
   /**
    * Set dynamic context (from useAIContext hook)
    */
@@ -2020,6 +3244,15 @@ var ChatWithTools = class {
   setBody(body) {
     this.chat.setBody(body);
   }
+  setRequestMessageTransform(fn) {
+    this.chat.setRequestMessageTransform(fn);
+  }
+  /**
+   * Set inline skills (forwarded to underlying chat instance)
+   */
+  setInlineSkills(skills) {
+    this.chat.setInlineSkills(skills);
+  }
   // ============================================
   // Tool Registration
   // ============================================
@@ -2096,16 +3329,307 @@ var ChatWithTools = class {
   // Private
   // ============================================
   debug(message, ...args) {
-    if (this.config.debug) {
-      console.log(`[ChatWithTools] ${message}`, ...args);
+    chunkI3SQUNTT_cjs.createLogger("tools", () => this.config.debug ?? false)(
+      message,
+      args.length === 1 ? args[0] : args.length > 1 ? args : void 0
+    );
+  }
+};
+
+// src/chat/branching/MessageTree.ts
+var _MessageTree = class _MessageTree {
+  constructor(messages) {
+    /** All messages by ID */
+    this.nodeMap = /* @__PURE__ */ new Map();
+    /** parentKey → ordered list of child IDs (insertion order = oldest-first) */
+    this.childrenOf = /* @__PURE__ */ new Map();
+    /** parentKey → currently-active child ID */
+    this.activeChildMap = /* @__PURE__ */ new Map();
+    /** Current leaf message ID (tip of the active path) */
+    this._currentLeafId = null;
+    /** Cached visible messages — invalidated on every mutation */
+    this._visibleCache = null;
+    if (messages?.length) {
+      this._buildFromMessages(messages);
+    }
+  }
+  // ============================================
+  // Static Migration Helpers
+  // ============================================
+  /**
+   * Convert a legacy flat array (no parentId) to a tree-linked array.
+   *
+   * Rules:
+   * - Tool messages get parentId = the owning assistant message's id
+   *   (matched via toolCallId → toolCall.id).
+   * - All other messages get parentId of the previous non-tool message
+   *   (or null for the first message).
+   *
+   * Returns a new array with parentId/childrenIds filled in.
+   * Does NOT mutate the original messages.
+   */
+  static fromFlatArray(messages) {
+    if (messages.length === 0) return messages;
+    const alreadyLinked = messages.some((m) => m.parentId !== void 0);
+    if (alreadyLinked) return messages;
+    const result = [];
+    let prevNonToolId = null;
+    const assistantById = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "assistant") {
+        assistantById.set(msg.id, msg);
+      }
+    }
+    for (const msg of messages) {
+      if (msg.role === "tool" && msg.toolCallId) {
+        let ownerAssistantId = null;
+        for (const [, assistant] of assistantById) {
+          if (assistant.toolCalls?.some((tc) => tc.id === msg.toolCallId)) {
+            ownerAssistantId = assistant.id;
+            break;
+          }
+        }
+        result.push({
+          ...msg,
+          parentId: ownerAssistantId ?? prevNonToolId,
+          childrenIds: []
+        });
+      } else {
+        result.push({
+          ...msg,
+          parentId: prevNonToolId,
+          childrenIds: []
+        });
+        prevNonToolId = msg.id;
+      }
+    }
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const msg of result) {
+      const parentKey = msg.parentId == null ? _MessageTree.ROOT_KEY : msg.parentId;
+      if (!childrenMap.has(parentKey)) {
+        childrenMap.set(parentKey, []);
+      }
+      childrenMap.get(parentKey).push(msg.id);
+    }
+    return result.map((msg) => ({
+      ...msg,
+      childrenIds: childrenMap.get(msg.id) ?? []
+    }));
+  }
+  // ============================================
+  // Core Queries
+  // ============================================
+  /**
+   * Returns the visible path (root → current leaf) — what the UI renders
+   * and what gets sent to the API.
+   *
+   * Backward-compat: if NO message has parentId set (all undefined),
+   * falls back to insertion order (legacy linear mode).
+   */
+  getVisibleMessages() {
+    if (this._visibleCache !== null) return this._visibleCache;
+    if (this.nodeMap.size === 0) {
+      this._visibleCache = [];
+      return this._visibleCache;
+    }
+    const hasTreeStructure = Array.from(this.nodeMap.values()).some(
+      (m) => m.parentId !== void 0
+    );
+    this._visibleCache = hasTreeStructure ? this._getActivePath().map((id) => this.nodeMap.get(id)) : Array.from(this.nodeMap.values());
+    return this._visibleCache;
+  }
+  _invalidateCache() {
+    this._visibleCache = null;
+  }
+  /**
+   * Returns ALL messages across every branch (for persistence / ThreadManager).
+   */
+  getAllMessages() {
+    return Array.from(this.nodeMap.values());
+  }
+  /**
+   * Branch navigation info for the UI navigator.
+   * Returns null if the message has no siblings (only child).
+   */
+  getBranchInfo(messageId) {
+    const msg = this.nodeMap.get(messageId);
+    if (!msg) return null;
+    const parentKey = this._parentKey(msg.parentId);
+    const siblings = this.childrenOf.get(parentKey) ?? [];
+    if (siblings.length <= 1) return null;
+    const siblingIndex = siblings.indexOf(messageId);
+    return {
+      siblingIndex,
+      totalSiblings: siblings.length,
+      siblingIds: [...siblings],
+      hasPrevious: siblingIndex > 0,
+      hasNext: siblingIndex < siblings.length - 1
+    };
+  }
+  get currentLeafId() {
+    return this._currentLeafId;
+  }
+  get hasBranches() {
+    for (const children of this.childrenOf.values()) {
+      if (children.length > 1) return true;
+    }
+    return false;
+  }
+  // ============================================
+  // Mutations
+  // ============================================
+  /**
+   * Insert a new message.
+   * - Updates childrenOf and nodeMap.
+   * - New branch becomes active (activeChildMap updated).
+   * - Updates current leaf.
+   */
+  addMessage(message) {
+    this.nodeMap.set(message.id, message);
+    const parentKey = this._parentKey(message.parentId);
+    if (!this.childrenOf.has(parentKey)) {
+      this.childrenOf.set(parentKey, []);
+    }
+    const siblings = this.childrenOf.get(parentKey);
+    if (!siblings.includes(message.id)) {
+      siblings.push(message.id);
+    }
+    this.activeChildMap.set(parentKey, message.id);
+    this._currentLeafId = this._walkToLeaf(message.id);
+    this._invalidateCache();
+    return message;
+  }
+  /**
+   * Navigate: make messageId the active child at its parent fork,
+   * then walk to its leaf and update currentLeafId.
+   */
+  switchBranch(messageId) {
+    const msg = this.nodeMap.get(messageId);
+    if (!msg) return;
+    const parentKey = this._parentKey(msg.parentId);
+    this.activeChildMap.set(parentKey, messageId);
+    this._currentLeafId = this._walkToLeaf(messageId);
+    this._invalidateCache();
+  }
+  /**
+   * Update message content in-place (streaming updates).
+   * No tree structure change.
+   */
+  updateMessage(id, updater) {
+    const existing = this.nodeMap.get(id);
+    if (!existing) return false;
+    this.nodeMap.set(id, updater(existing));
+    this._invalidateCache();
+    return true;
+  }
+  /**
+   * Set current leaf explicitly.
+   * Used by regenerate() to rewind the active path before pushing a new message.
+   */
+  setCurrentLeaf(leafId) {
+    this._currentLeafId = leafId;
+    if (leafId === null) return;
+    const msg = this.nodeMap.get(leafId);
+    if (!msg) return;
+    let current = msg;
+    while (current) {
+      const parentKey = this._parentKey(current.parentId);
+      this.activeChildMap.set(parentKey, current.id);
+      if (current.parentId == null || current.parentId === void 0) break;
+      current = this.nodeMap.get(current.parentId);
+    }
+    this._invalidateCache();
+  }
+  /**
+   * Rebuild entire tree from a message array.
+   * Used by setMessages().
+   */
+  reset(messages) {
+    this.nodeMap.clear();
+    this.childrenOf.clear();
+    this.activeChildMap.clear();
+    this._currentLeafId = null;
+    this._invalidateCache();
+    if (messages.length > 0) {
+      this._buildFromMessages(messages);
+    }
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  _buildFromMessages(messages) {
+    const linked = messages.some((m) => m.parentId !== void 0) ? messages : _MessageTree.fromFlatArray(messages);
+    for (const msg of linked) {
+      this.nodeMap.set(msg.id, msg);
+      const parentKey = this._parentKey(msg.parentId);
+      if (!this.childrenOf.has(parentKey)) {
+        this.childrenOf.set(parentKey, []);
+      }
+      const siblings = this.childrenOf.get(parentKey);
+      if (!siblings.includes(msg.id)) {
+        siblings.push(msg.id);
+      }
+    }
+    for (const [parentKey, children] of this.childrenOf) {
+      if (children.length > 0) {
+        this.activeChildMap.set(parentKey, children[children.length - 1]);
+      }
+    }
+    const path = this._getActivePath();
+    this._currentLeafId = path.length > 0 ? path[path.length - 1] : null;
+  }
+  _parentKey(parentId) {
+    if (parentId == null || parentId === void 0) {
+      return _MessageTree.ROOT_KEY;
+    }
+    return parentId;
+  }
+  /**
+   * Walk forward from a message along active children to find the leaf.
+   */
+  _walkToLeaf(fromId) {
+    let current = fromId;
+    while (true) {
+      const children = this.childrenOf.get(current);
+      if (!children || children.length === 0) break;
+      const activeChild = this.activeChildMap.get(current);
+      if (!activeChild) break;
+      if (!this.nodeMap.has(activeChild)) break;
+      current = activeChild;
+    }
+    return current;
+  }
+  /**
+   * Walk the active path from root to the current leaf.
+   */
+  _getActivePath() {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    const rootChildren = this.childrenOf.get(_MessageTree.ROOT_KEY) ?? [];
+    if (rootChildren.length === 0) return path;
+    let activeId = this.activeChildMap.get(_MessageTree.ROOT_KEY);
+    if (!activeId) {
+      activeId = rootChildren[rootChildren.length - 1];
     }
+    let current = activeId;
+    while (current && !visited.has(current)) {
+      if (!this.nodeMap.has(current)) break;
+      visited.add(current);
+      path.push(current);
+      const activeChild = this.activeChildMap.get(current);
+      if (!activeChild || !this.nodeMap.has(activeChild)) break;
+      current = activeChild;
+    }
+    return path;
   }
 };
+/** Sentinel key used for root-level messages (parentId === null) */
+_MessageTree.ROOT_KEY = "__root__";
+var MessageTree = _MessageTree;
 
 // src/react/internal/ReactChatState.ts
 var ReactChatState = class {
   constructor(initialMessages) {
-    this._messages = [];
     this._status = "ready";
     this._error = void 0;
     // Callbacks for React subscriptions (useSyncExternalStore)
@@ -2131,15 +3655,19 @@ var ReactChatState = class {
         this.subscribers.delete(callback);
       };
     };
-    if (initialMessages) {
-      this._messages = initialMessages;
-    }
+    this.tree = new MessageTree(initialMessages);
   }
   // ============================================
-  // Getters
+  // Getters — visible path only
   // ============================================
+  /**
+   * Returns the VISIBLE PATH (active branch) — what the UI renders
+   * and what gets sent to the API.
+   *
+   * For all messages across all branches, use getAllMessages().
+   */
   get messages() {
-    return this._messages;
+    return this.tree.getVisibleMessages();
   }
   get status() {
     return this._status;
@@ -2151,7 +3679,7 @@ var ReactChatState = class {
   // Setters (trigger reactivity)
   // ============================================
   set messages(value) {
-    this._messages = value;
+    this.tree.reset(value);
     this.notify();
   }
   set status(value) {
@@ -2166,63 +3694,102 @@ var ReactChatState = class {
   // Mutations
   // ============================================
   pushMessage(message) {
-    this._messages = [...this._messages, message];
+    this.tree.addMessage(message);
     this.notify();
   }
   popMessage() {
-    this._messages = this._messages.slice(0, -1);
+    const leafId = this.tree.currentLeafId;
+    if (!leafId) return;
+    const allMessages = this.tree.getAllMessages().filter((m) => m.id !== leafId);
+    const leaf = this.tree.getAllMessages().find((m) => m.id === leafId);
+    const newLeafId = leaf && leaf.parentId !== void 0 && leaf.parentId !== null ? leaf.parentId : null;
+    this.tree.reset(allMessages);
+    if (newLeafId) {
+      this.tree.setCurrentLeaf(newLeafId);
+    }
     this.notify();
   }
   replaceMessage(index, message) {
-    this._messages = this._messages.map((m, i) => i === index ? message : m);
+    const visible = this.tree.getVisibleMessages();
+    const target = visible[index];
+    if (!target) return;
+    this.tree.updateMessage(target.id, () => message);
     this.notify();
   }
   updateLastMessage(updater) {
-    if (this._messages.length === 0) return;
-    const lastIndex = this._messages.length - 1;
-    const lastMessage = this._messages[lastIndex];
-    this._messages = [
-      ...this._messages.slice(0, lastIndex),
-      updater(lastMessage)
-    ];
+    const leafId = this.tree.currentLeafId;
+    if (!leafId) return;
+    this.tree.updateMessage(leafId, updater);
     this.notify();
   }
   updateMessageById(id, updater) {
-    const index = this._messages.findIndex((m) => m.id === id);
-    if (index === -1) return false;
-    this._messages = this._messages.map(
-      (m, i) => i === index ? updater(m) : m
-    );
-    this.notify();
-    return true;
+    const updated = this.tree.updateMessage(id, updater);
+    if (updated) this.notify();
+    return updated;
   }
   setMessages(messages) {
-    this._messages = messages;
+    this.tree.reset(messages);
     this.notify();
   }
   clearMessages() {
-    this._messages = [];
+    this.tree.reset([]);
     this.notify();
   }
   // ============================================
-  // Private Methods
+  // Branching API
   // ============================================
-  notify() {
-    this.subscribers.forEach((cb) => cb());
-  }
   /**
-   * Cleanup subscriptions
+   * Returns ALL messages across all branches.
+   * Use this for persistence (ThreadManager save).
    */
-  dispose() {
-    this.subscribers.clear();
+  getAllMessages() {
+    return this.tree.getAllMessages();
   }
   /**
-   * Revive after dispose (for React StrictMode compatibility)
-   * Subscribers will be re-added automatically via useSyncExternalStore
+   * Get branch navigation info for a message.
+   * Returns null if the message has no siblings.
    */
-  revive() {
+  getBranchInfo(messageId) {
+    return this.tree.getBranchInfo(messageId);
   }
-};
+  /**
+   * Navigate to a sibling branch.
+   * Triggers re-render via notify().
+   */
+  switchBranch(messageId) {
+    this.tree.switchBranch(messageId);
+    this.notify();
+  }
+  /**
+   * Set the current leaf (used by regenerate() to rewind active path).
+   * Triggers re-render via notify().
+   */
+  setCurrentLeaf(leafId) {
+    this.tree.setCurrentLeaf(leafId);
+    this.notify();
+  }
+  get hasBranches() {
+    return this.tree.hasBranches;
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  notify() {
+    this.subscribers.forEach((cb) => cb());
+  }
+  /**
+   * Cleanup subscriptions
+   */
+  dispose() {
+    this.subscribers.clear();
+  }
+  /**
+   * Revive after dispose (for React StrictMode compatibility)
+   * Subscribers will be re-added automatically via useSyncExternalStore
+   */
+  revive() {
+  }
+};
 function createReactChatState(initialMessages) {
   return new ReactChatState(initialMessages);
 }
@@ -2240,6 +3807,33 @@ var ReactChatWithTools = class extends ChatWithTools {
     };
     this.reactState = reactState;
   }
+  // ============================================
+  // Branching API — pass-throughs to ReactChatState
+  // ============================================
+  /**
+   * Navigate to a sibling branch.
+   */
+  switchBranch(messageId) {
+    this.reactState.switchBranch(messageId);
+  }
+  /**
+   * Get branch navigation info for a message.
+   */
+  getBranchInfo(messageId) {
+    return this.reactState.getBranchInfo(messageId);
+  }
+  /**
+   * Get all messages across all branches (for persistence).
+   */
+  getAllMessages() {
+    return this.reactState.getAllMessages();
+  }
+  /**
+   * Whether any message has siblings (branching has occurred).
+   */
+  get hasBranches() {
+    return this.reactState.hasBranches;
+  }
   /**
    * Dispose and cleanup
    */
@@ -2337,13 +3931,13 @@ function useMCPClient(config) {
     onNotification,
     ...clientConfig
   } = config;
-  const clientRef = react.useRef(null);
-  const mountedRef = react.useRef(true);
-  const [state, setState] = react.useState({
+  const clientRef = React2.useRef(null);
+  const mountedRef = React2.useRef(true);
+  const [state, setState] = React2.useState({
     connectionState: "disconnected",
     tools: []
   });
-  const getClient = react.useCallback(() => {
+  const getClient = React2.useCallback(() => {
     if (!clientRef.current) {
       clientRef.current = chunkJGPDQDY4_cjs.createMCPClient(clientConfig, {
         onConnectionStateChange: (newState) => {
@@ -2377,7 +3971,7 @@ function useMCPClient(config) {
     onError,
     onNotification
   ]);
-  const connect = react.useCallback(async () => {
+  const connect = React2.useCallback(async () => {
     const client = getClient();
     try {
       setState((prev) => ({
@@ -2408,7 +4002,7 @@ function useMCPClient(config) {
       throw error;
     }
   }, [getClient]);
-  const disconnect = react.useCallback(async () => {
+  const disconnect = React2.useCallback(async () => {
     const client = clientRef.current;
     if (client) {
       await client.disconnect();
@@ -2420,7 +4014,7 @@ function useMCPClient(config) {
       }
     }
   }, []);
-  const callTool = react.useCallback(
+  const callTool = React2.useCallback(
     async (name, args) => {
       const client = clientRef.current;
       if (!client || !client.isConnected()) {
@@ -2434,7 +4028,7 @@ function useMCPClient(config) {
     },
     []
   );
-  const refreshTools = react.useCallback(async () => {
+  const refreshTools = React2.useCallback(async () => {
     const client = clientRef.current;
     if (!client || !client.isConnected()) {
       throw new Error("MCP client not connected");
@@ -2445,7 +4039,7 @@ function useMCPClient(config) {
     }
     return tools;
   }, []);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     mountedRef.current = true;
     if (autoConnect) {
       connect().catch(() => {
@@ -2484,13 +4078,13 @@ function useMCPTools(config) {
     ...clientConfig
   } = config;
   const { registerTool, unregisterTool } = useCopilot();
-  const registeredToolsRef = react.useRef([]);
+  const registeredToolsRef = React2.useRef([]);
   const mcpClient = useMCPClient(clientConfig);
-  const toolAdapter = react.useMemo(
+  const toolAdapter = React2.useMemo(
     () => new chunkJGPDQDY4_cjs.MCPToolAdapter(clientConfig.name),
     [clientConfig.name]
   );
-  const toolDefinitions = react.useMemo(() => {
+  const toolDefinitions = React2.useMemo(() => {
     if (!mcpClient.isConnected || mcpClient.state.tools.length === 0) {
       return [];
     }
@@ -2515,7 +4109,7 @@ function useMCPTools(config) {
     hidden,
     source
   ]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (!autoRegister) {
       return;
     }
@@ -2530,22 +4124,919 @@ function useMCPTools(config) {
       }
     }
     return () => {
-      for (const toolName of registeredToolsRef.current) {
-        unregisterTool(toolName);
+      for (const toolName of registeredToolsRef.current) {
+        unregisterTool(toolName);
+      }
+      registeredToolsRef.current = [];
+    };
+  }, [
+    autoRegister,
+    mcpClient.isConnected,
+    toolDefinitions,
+    registerTool,
+    unregisterTool
+  ]);
+  return {
+    ...mcpClient,
+    toolDefinitions
+  };
+}
+var defaultTokenUsage = {
+  current: 0,
+  max: 128e3,
+  percentage: 0,
+  isApproaching: false
+};
+var defaultCompactionState = {
+  rollingSummary: null,
+  lastCompactionAt: null,
+  compactionCount: 0,
+  totalTokensSaved: 0,
+  workingMemory: [],
+  displayMessageCount: 0,
+  llmMessageCount: 0
+};
+var defaultMessageHistoryConfig = {
+  strategy: "none",
+  maxContextTokens: 128e3,
+  reserveForResponse: 4096,
+  compactionThreshold: 0.75,
+  recentBuffer: 10,
+  toolResultMaxChars: 1e4,
+  persistSession: false,
+  storageKey: "copilot-session"
+};
+var MessageHistoryContext = React2.createContext({
+  config: defaultMessageHistoryConfig,
+  tokenUsage: defaultTokenUsage,
+  compactionState: defaultCompactionState
+});
+function useMessageHistoryContext() {
+  return React2.useContext(MessageHistoryContext);
+}
+
+// src/react/message-history/message-utils.ts
+function toDisplayMessage(msg) {
+  return {
+    ...msg,
+    timestamp: msg.createdAt instanceof Date ? msg.createdAt.getTime() : Date.now()
+  };
+}
+function toLLMMessage(msg) {
+  if (isCompactionMarker(msg)) {
+    return {
+      role: "system",
+      content: `[Previous conversation summary]
+${msg.content}`
+    };
+  }
+  const base = {
+    role: msg.role,
+    content: msg.content
+  };
+  if (msg.toolCalls?.length) {
+    base.tool_calls = msg.toolCalls;
+  }
+  if (msg.toolCallId) {
+    base.tool_call_id = msg.toolCallId;
+  }
+  return base;
+}
+function toLLMMessages(messages) {
+  return messages.map(toLLMMessage);
+}
+function keepToolPairsAtomic(messages) {
+  if (messages.length === 0) return messages;
+  const firstIdx = messages.findIndex((msg, i) => {
+    if (msg.role !== "assistant" || !msg.toolCalls?.length) return false;
+    const toolCallIds = new Set(msg.toolCalls.map((tc) => tc.id));
+    const resultIds = new Set(
+      messages.slice(i + 1).filter((m) => m.role === "tool" && m.toolCallId).map((m) => m.toolCallId)
+    );
+    return [...toolCallIds].some((id) => !resultIds.has(id));
+  });
+  if (firstIdx === -1) return messages;
+  return messages.slice(firstIdx);
+}
+function findSafeWindowStart(messages, desiredStart) {
+  for (let i = desiredStart; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "user" || msg.role === "assistant" && !msg.toolCalls?.length) {
+      return i;
+    }
+  }
+  return desiredStart;
+}
+function isCompactionMarker(msg) {
+  return msg.role === "system" && msg.type === "compaction-marker";
+}
+
+// src/react/message-history/token-counter.ts
+function estimateMessageTokens2(msg) {
+  let chars = msg.content?.length ?? 0;
+  if (msg.tool_calls?.length) {
+    for (const tc of msg.tool_calls) {
+      chars += JSON.stringify(tc).length;
+    }
+  }
+  return Math.ceil(chars / 3.5) + 4;
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, msg) => sum + estimateMessageTokens2(msg), 0);
+}
+function estimateTokens2(messages, mode = "fast") {
+  if (mode === "off") return 0;
+  return estimateMessagesTokens(messages);
+}
+
+// src/react/message-history/strategies/sliding-window.ts
+function applySlidingWindow(messages, options) {
+  const { tokenBudget, recentBuffer } = options;
+  if (messages.length === 0) return messages;
+  const systemMessages = messages.filter(
+    (m) => m.role === "system" || isCompactionMarker(m)
+  );
+  const conversationMessages = messages.filter(
+    (m) => m.role !== "system" && !isCompactionMarker(m)
+  );
+  const systemTokens = estimateMessagesTokens(toLLMMessages(systemMessages));
+  const remainingBudget = tokenBudget - systemTokens;
+  if (conversationMessages.length === 0) return systemMessages;
+  const recentStart = Math.max(0, conversationMessages.length - recentBuffer);
+  const recent = conversationMessages.slice(recentStart);
+  const older = conversationMessages.slice(0, recentStart);
+  const allTokens = estimateMessagesTokens(toLLMMessages(conversationMessages));
+  if (allTokens <= remainingBudget) {
+    return messages;
+  }
+  const recentTokens = estimateMessagesTokens(toLLMMessages(recent));
+  let available = remainingBudget - recentTokens;
+  const included = [];
+  for (let i = older.length - 1; i >= 0; i--) {
+    const msgTokens = estimateMessagesTokens(toLLMMessages([older[i]]));
+    if (available - msgTokens < 0) break;
+    included.unshift(older[i]);
+    available -= msgTokens;
+  }
+  const combined = [...included, ...recent];
+  const safeStart = findSafeWindowStart(combined, 0);
+  const safeWindow = combined.slice(safeStart);
+  return [...systemMessages, ...safeWindow];
+}
+function truncateToolResults(messages, maxChars) {
+  if (maxChars === 0) return messages;
+  return messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    if (!msg.content || msg.content.length <= maxChars) return msg;
+    return {
+      ...msg,
+      content: msg.content.slice(0, maxChars) + `
+[truncated \u2014 original ${msg.content.length} chars, limit ${maxChars}]`
+    };
+  });
+}
+
+// src/react/message-history/strategies/selective-prune.ts
+function applySelectivePrune(displayMessages, recentBuffer, options = {}) {
+  const {
+    toolResultAgeTurns = 3,
+    stripOldReasoning = true,
+    deduplicateSkills = true
+  } = options;
+  const cutoff = Math.max(0, displayMessages.length - recentBuffer);
+  const seenSkillContent = /* @__PURE__ */ new Set();
+  return displayMessages.map((msg, idx) => {
+    const llm = toLLMMessage(msg);
+    const isOld = idx < cutoff;
+    if (deduplicateSkills && msg.role === "system" && llm.content) {
+      const key = llm.content.slice(0, 100);
+      if (seenSkillContent.has(key)) {
+        return { ...llm, content: "[skill instruction \u2014 deduplicated]" };
+      }
+      seenSkillContent.add(key);
+    }
+    if (!isOld) return llm;
+    if (stripOldReasoning && msg.role === "assistant" && msg.thinking) {
+      llm.content = llm.content;
+    }
+    if (msg.role === "tool" && llm.content) {
+      const originalSize = llm.content.length;
+      if (originalSize > 500) {
+        const stub = buildToolResultStub(msg, llm.content);
+        return {
+          role: "tool",
+          tool_call_id: llm.tool_call_id,
+          content: JSON.stringify(stub)
+        };
+      }
+    }
+    return llm;
+  });
+}
+function buildToolResultStub(msg, content) {
+  return {
+    type: "compacted-tool-result",
+    toolName: msg.metadata?.toolName ?? "tool",
+    toolCallId: msg.toolCallId ?? "",
+    args: msg.metadata?.toolArgs ?? {},
+    executedAt: msg.timestamp,
+    status: content.includes('"error"') ? "error" : "success",
+    originalSize: content.length,
+    summary: buildSummary(content),
+    extract: content.slice(0, 200)
+  };
+}
+function buildSummary(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed?.message) return String(parsed.message).slice(0, 120);
+    if (parsed?.error) return `Error: ${String(parsed.error).slice(0, 100)}`;
+    if (Array.isArray(parsed)) return `Array result \u2014 ${parsed.length} items`;
+    const keys = Object.keys(parsed).slice(0, 3).join(", ");
+    return `Object result \u2014 keys: ${keys}`;
+  } catch {
+    return content.slice(0, 120);
+  }
+}
+
+// src/react/message-history/strategies/summary-buffer.ts
+function buildSummaryBufferContext(displayMessages, compactionState, options) {
+  const { recentBuffer } = options;
+  const systemMessages = displayMessages.filter(
+    (m) => m.role === "system" || isCompactionMarker(m)
+  );
+  const conversationMessages = displayMessages.filter(
+    (m) => m.role !== "system" && !isCompactionMarker(m)
+  );
+  const recentStart = Math.max(0, conversationMessages.length - recentBuffer);
+  const recentMessages = conversationMessages.slice(recentStart);
+  const result = [];
+  if (compactionState.workingMemory.length > 0) {
+    result.push({
+      role: "system",
+      content: `[Working memory \u2014 always active]
+${compactionState.workingMemory.join("\n")}`
+    });
+  }
+  if (compactionState.rollingSummary) {
+    result.push({
+      role: "system",
+      content: `[Previous conversation summary]
+${compactionState.rollingSummary}`
+    });
+  }
+  result.push(...toLLMMessages(systemMessages));
+  result.push(...toLLMMessages(recentMessages));
+  return result;
+}
+async function runCompaction(displayMessages, compactionState, options) {
+  const { recentBuffer, compactionUrl, summarizer } = options;
+  const conversationMessages = displayMessages.filter(
+    (m) => m.role !== "system" && !isCompactionMarker(m)
+  );
+  const cutoff = Math.max(0, conversationMessages.length - recentBuffer);
+  const toSummarize = conversationMessages.slice(0, cutoff);
+  if (toSummarize.length === 0) {
+    return { llmMessages: toLLMMessages(displayMessages) };
+  }
+  const llmToSummarize = toLLMMessages(toSummarize);
+  const originalTokens = estimateMessagesTokens(llmToSummarize);
+  let newSummary;
+  if (summarizer) {
+    newSummary = await summarizer(llmToSummarize);
+  } else if (compactionUrl) {
+    newSummary = await fetchSummary(compactionUrl, {
+      messages: llmToSummarize,
+      existingSummary: compactionState.rollingSummary,
+      workingMemory: compactionState.workingMemory
+    });
+  } else {
+    newSummary = buildFallbackSummary(
+      llmToSummarize,
+      compactionState.rollingSummary
+    );
+  }
+  const summaryTokens = Math.ceil(newSummary.length / 3.5);
+  const tokensSaved = Math.max(0, originalTokens - summaryTokens);
+  return {
+    llmMessages: buildSummaryBufferContext(
+      displayMessages,
+      { ...compactionState, rollingSummary: newSummary },
+      options
+    ),
+    newSummary,
+    tokensSaved,
+    messagesSummarized: toSummarize.length
+  };
+}
+async function fetchSummary(url, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Compaction endpoint returned ${res.status}`);
+  }
+  const data = await res.json();
+  if (!data?.summary) {
+    throw new Error("Compaction endpoint did not return { summary: string }");
+  }
+  return data.summary;
+}
+function buildFallbackSummary(messages, existingSummary) {
+  const lines = messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => `${m.role}: ${(m.content ?? "").slice(0, 200)}`).join("\n");
+  return existingSummary ? `${existingSummary}
+
+[Additional context]
+${lines}` : lines;
+}
+
+// src/react/message-history/session-persistence.ts
+var IDB_DB_NAME = "copilot-sdk";
+var IDB_STORE = "sessions";
+var IDB_VERSION = 1;
+function saveCompactionState(storageKey, state) {
+  try {
+    localStorage.setItem(
+      `${storageKey}-state`,
+      JSON.stringify({ ...state, _savedAt: Date.now() })
+    );
+  } catch {
+  }
+}
+function loadCompactionState(storageKey) {
+  try {
+    const raw = localStorage.getItem(`${storageKey}-state`);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    delete parsed._savedAt;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearCompactionState(storageKey) {
+  try {
+    localStorage.removeItem(`${storageKey}-state`);
+  } catch {
+  }
+}
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(IDB_DB_NAME, IDB_VERSION);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(IDB_STORE, { keyPath: "sessionId" });
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function saveDisplayMessages(storageKey, messages) {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(IDB_STORE, "readwrite");
+    tx.objectStore(IDB_STORE).put({
+      sessionId: storageKey,
+      messages,
+      savedAt: Date.now()
+    });
+    await new Promise((res, rej) => {
+      tx.oncomplete = () => res();
+      tx.onerror = () => rej(tx.error);
+    });
+    db.close();
+  } catch {
+  }
+}
+async function loadDisplayMessages(storageKey) {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(IDB_STORE, "readonly");
+    const req = tx.objectStore(IDB_STORE).get(storageKey);
+    const result = await new Promise((res, rej) => {
+      req.onsuccess = () => res(req.result);
+      req.onerror = () => rej(req.error);
+    });
+    db.close();
+    return result?.messages ?? null;
+  } catch {
+    return null;
+  }
+}
+async function clearDisplayMessages(storageKey) {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(IDB_STORE, "readwrite");
+    tx.objectStore(IDB_STORE).delete(storageKey);
+    await new Promise((res, rej) => {
+      tx.oncomplete = () => res();
+      tx.onerror = () => rej(tx.error);
+    });
+    db.close();
+  } catch {
+  }
+}
+async function clearSession(storageKey) {
+  clearCompactionState(storageKey);
+  await clearDisplayMessages(storageKey);
+}
+
+// src/react/message-history/useMessageHistory.ts
+var DEFAULT_COMPACTION_STATE = {
+  rollingSummary: null,
+  lastCompactionAt: null,
+  compactionCount: 0,
+  totalTokensSaved: 0,
+  workingMemory: [],
+  displayMessageCount: 0,
+  llmMessageCount: 0
+};
+function useMessageHistory(options = {}) {
+  const { messages } = useCopilot();
+  const ctx = useMessageHistoryContext();
+  const config = React2.useMemo(
+    () => ({ ...defaultMessageHistoryConfig, ...ctx.config, ...options }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      ctx.config,
+      options.strategy,
+      options.maxContextTokens,
+      options.recentBuffer,
+      options.compactionThreshold
+    ]
+  );
+  const storageKey = config.storageKey ?? "copilot-session";
+  const strategy = options.skipCompaction ? "none" : config.strategy ?? "none";
+  const [compactionState, setCompactionState] = React2.useState(() => {
+    if (config.persistSession) {
+      return loadCompactionState(storageKey) ?? DEFAULT_COMPACTION_STATE;
+    }
+    return DEFAULT_COMPACTION_STATE;
+  });
+  const displayMessages = React2.useMemo(
+    () => messages.map(toDisplayMessage),
+    [messages]
+  );
+  const restoredRef = React2.useRef(false);
+  React2.useEffect(() => {
+    if (!config.persistSession || restoredRef.current) return;
+    restoredRef.current = true;
+    loadDisplayMessages(storageKey).then((saved) => {
+      if (saved?.length && messages.length === 0) ;
+    });
+  }, [config.persistSession, storageKey, messages.length]);
+  React2.useEffect(() => {
+    if (!config.persistSession || displayMessages.length === 0) return;
+    saveDisplayMessages(storageKey, displayMessages);
+  }, [config.persistSession, storageKey, displayMessages]);
+  const llmMessages = React2.useMemo(() => {
+    const maxTokens = config.maxContextTokens ?? 128e3;
+    const reserve = config.reserveForResponse ?? 4096;
+    const tokenBudget = maxTokens - reserve;
+    const recentBuffer = config.recentBuffer ?? 10;
+    const maxChars = config.toolResultMaxChars ?? 1e4;
+    let result;
+    switch (strategy) {
+      case "sliding-window": {
+        const windowed = applySlidingWindow(displayMessages, {
+          tokenBudget,
+          recentBuffer
+        });
+        result = truncateToolResults(toLLMMessages(windowed), maxChars);
+        break;
+      }
+      case "selective-prune": {
+        result = truncateToolResults(
+          applySelectivePrune(displayMessages, recentBuffer),
+          maxChars
+        );
+        break;
+      }
+      case "summary-buffer": {
+        result = truncateToolResults(
+          buildSummaryBufferContext(displayMessages, compactionState, {
+            recentBuffer,
+            compactionThreshold: config.compactionThreshold ?? 0.75,
+            compactionUrl: config.compactionUrl,
+            summarizer: options.summarizer
+          }),
+          maxChars
+        );
+        break;
+      }
+      default:
+        result = truncateToolResults(toLLMMessages(displayMessages), maxChars);
+    }
+    return result;
+  }, [displayMessages, compactionState, strategy, config, options.summarizer]);
+  const tokenUsage = React2.useMemo(() => {
+    const mode = options.tokenEstimation ?? "fast";
+    const current = estimateTokens2(toLLMMessages(displayMessages), mode);
+    const max = config.maxContextTokens ?? 128e3;
+    const threshold = config.compactionThreshold ?? 0.75;
+    const percentage = current / max;
+    return { current, max, percentage, isApproaching: percentage >= threshold };
+  }, [
+    displayMessages,
+    config.maxContextTokens,
+    config.compactionThreshold,
+    options.tokenEstimation
+  ]);
+  React2.useEffect(() => {
+    if (config.onTokenUsage && tokenUsage.current > 0) {
+      config.onTokenUsage(tokenUsage);
+    }
+  }, [tokenUsage, config.onTokenUsage]);
+  React2.useEffect(() => {
+    if (config.persistSession) {
+      saveCompactionState(storageKey, {
+        ...compactionState,
+        displayMessageCount: displayMessages.length,
+        llmMessageCount: llmMessages.length
+      });
+    }
+  }, [
+    config.persistSession,
+    storageKey,
+    compactionState,
+    displayMessages.length,
+    llmMessages.length
+  ]);
+  const isCompactingRef = React2.useRef(false);
+  const [isCompacting, setIsCompacting] = React2.useState(false);
+  React2.useEffect(() => {
+    if (strategy !== "summary-buffer" || options.skipCompaction || isCompactingRef.current || !tokenUsage.isApproaching)
+      return;
+    isCompactingRef.current = true;
+    setIsCompacting(true);
+    runCompaction(displayMessages, compactionState, {
+      recentBuffer: config.recentBuffer ?? 10,
+      tokenBudget: (config.maxContextTokens ?? 128e3) - (config.reserveForResponse ?? 4096),
+      compactionThreshold: config.compactionThreshold ?? 0.75,
+      compactionUrl: config.compactionUrl,
+      summarizer: options.summarizer
+    }).then((result) => {
+      if (result.newSummary) {
+        const event = {
+          type: "auto",
+          compactionCount: compactionState.compactionCount + 1,
+          messagesSummarized: result.messagesSummarized ?? 0,
+          tokensSaved: result.tokensSaved ?? 0,
+          timestamp: Date.now()
+        };
+        setCompactionState((prev) => ({
+          ...prev,
+          rollingSummary: result.newSummary,
+          lastCompactionAt: Date.now(),
+          compactionCount: prev.compactionCount + 1,
+          totalTokensSaved: prev.totalTokensSaved + (result.tokensSaved ?? 0)
+        }));
+        config.onCompaction?.(event);
+      }
+    }).finally(() => {
+      isCompactingRef.current = false;
+      setIsCompacting(false);
+    });
+  }, [tokenUsage.isApproaching, strategy]);
+  const compactSession = React2.useCallback(
+    async (instructions) => {
+      if (strategy !== "summary-buffer") return;
+      const result = await runCompaction(displayMessages, compactionState, {
+        recentBuffer: config.recentBuffer ?? 10,
+        tokenBudget: (config.maxContextTokens ?? 128e3) - (config.reserveForResponse ?? 4096),
+        compactionThreshold: config.compactionThreshold ?? 0.75,
+        compactionUrl: config.compactionUrl,
+        summarizer: options.summarizer ? (msgs) => options.summarizer(msgs) : instructions ? (msgs) => fetchWithInstructions(config.compactionUrl, msgs, instructions) : void 0
+      });
+      if (result.newSummary) {
+        const event = {
+          type: "manual",
+          compactionCount: compactionState.compactionCount + 1,
+          messagesSummarized: result.messagesSummarized ?? 0,
+          tokensSaved: result.tokensSaved ?? 0,
+          timestamp: Date.now()
+        };
+        setCompactionState((prev) => ({
+          ...prev,
+          rollingSummary: result.newSummary,
+          lastCompactionAt: Date.now(),
+          compactionCount: prev.compactionCount + 1,
+          totalTokensSaved: prev.totalTokensSaved + (result.tokensSaved ?? 0)
+        }));
+        config.onCompaction?.(event);
+      }
+    },
+    [displayMessages, compactionState, config, strategy, options.summarizer]
+  );
+  const addToWorkingMemory = React2.useCallback((fact) => {
+    setCompactionState((prev) => ({
+      ...prev,
+      workingMemory: [...prev.workingMemory, fact]
+    }));
+  }, []);
+  const clearWorkingMemory = React2.useCallback(() => {
+    setCompactionState((prev) => ({ ...prev, workingMemory: [] }));
+  }, []);
+  const resetSession = React2.useCallback(async () => {
+    setCompactionState(DEFAULT_COMPACTION_STATE);
+    if (config.persistSession) {
+      await clearSession(storageKey);
+    }
+  }, [config.persistSession, storageKey]);
+  return {
+    displayMessages,
+    llmMessages,
+    tokenUsage,
+    isCompacting,
+    compactionState: {
+      ...compactionState,
+      displayMessageCount: displayMessages.length,
+      llmMessageCount: llmMessages.length
+    },
+    compactSession,
+    addToWorkingMemory,
+    clearWorkingMemory,
+    resetSession
+  };
+}
+async function fetchWithInstructions(url, messages, instructions) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ messages, instructions })
+  });
+  const data = await res.json();
+  return data.summary;
+}
+var SkillContext = React2.createContext(null);
+function useSkillContext() {
+  const ctx = React2.useContext(SkillContext);
+  if (!ctx) {
+    throw new Error("useSkillContext must be used within <SkillProvider>");
+  }
+  return ctx;
+}
+function useAIContext(item) {
+  const { addContext, removeContext } = useCopilot();
+  const contextIdRef = React2.useRef(null);
+  const serializedData = typeof item.data === "string" ? item.data : JSON.stringify(item.data);
+  React2.useEffect(() => {
+    const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
+    const contextString = item.description ? `${item.description}:
+${formattedValue}` : `${item.key}:
+${formattedValue}`;
+    contextIdRef.current = addContext(contextString, item.parentId);
+    return () => {
+      if (contextIdRef.current) {
+        removeContext(contextIdRef.current);
+        contextIdRef.current = null;
+      }
+    };
+  }, [
+    item.key,
+    serializedData,
+    item.description,
+    item.parentId,
+    addContext,
+    removeContext
+  ]);
+  return contextIdRef.current ?? void 0;
+}
+function useAIContexts(items) {
+  const { addContext, removeContext } = useCopilot();
+  const contextIdsRef = React2.useRef([]);
+  const serializedItems = JSON.stringify(
+    items.map((item) => ({
+      key: item.key,
+      data: item.data,
+      description: item.description,
+      parentId: item.parentId
+    }))
+  );
+  React2.useEffect(() => {
+    contextIdsRef.current.forEach((id) => removeContext(id));
+    contextIdsRef.current = [];
+    const parsedItems = JSON.parse(serializedItems);
+    for (const item of parsedItems) {
+      const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
+      const contextString = item.description ? `${item.description}:
+${formattedValue}` : `${item.key}:
+${formattedValue}`;
+      const id = addContext(contextString, item.parentId);
+      contextIdsRef.current.push(id);
+    }
+    return () => {
+      contextIdsRef.current.forEach((id) => removeContext(id));
+      contextIdsRef.current = [];
+    };
+  }, [serializedItems, addContext, removeContext]);
+}
+function isZodSchema(value) {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value;
+  return "_def" in obj && typeof obj._def === "object" || "_zod" in obj && typeof obj._zod === "object" || "~standard" in obj;
+}
+function useTool(config, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const configRef = React2.useRef(config);
+  configRef.current = config;
+  const inputSchema = React2.useMemo(() => {
+    if (isZodSchema(config.inputSchema)) {
+      return chunkI3SQUNTT_cjs.zodToJsonSchema(config.inputSchema);
+    }
+    return config.inputSchema;
+  }, [config.inputSchema]);
+  React2.useEffect(() => {
+    const tool2 = {
+      name: config.name,
+      description: config.description,
+      location: "client",
+      inputSchema,
+      handler: async (params, context) => {
+        return configRef.current.handler(params, context);
+      },
+      render: config.render,
+      available: config.available ?? true,
+      needsApproval: config.needsApproval,
+      approvalMessage: config.approvalMessage,
+      hidden: config.hidden,
+      deferLoading: config.deferLoading,
+      profiles: config.profiles,
+      searchKeywords: config.searchKeywords,
+      group: config.group,
+      category: config.category,
+      resultConfig: config.resultConfig,
+      title: config.title,
+      executingTitle: config.executingTitle,
+      completedTitle: config.completedTitle,
+      aiResponseMode: config.aiResponseMode,
+      aiContext: config.aiContext
+    };
+    registerTool(tool2);
+    return () => {
+      unregisterTool(config.name);
+    };
+  }, [config.name, inputSchema, ...dependencies]);
+}
+function useTools(tools) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const registeredToolsRef = React2.useRef([]);
+  const toolsRef = React2.useRef(tools);
+  toolsRef.current = tools;
+  const toolsKey = Object.keys(tools).sort().join(",");
+  React2.useEffect(() => {
+    const currentTools = toolsRef.current;
+    const toolNames = [];
+    for (const [name, toolDef] of Object.entries(currentTools)) {
+      const fullTool = {
+        ...toolDef,
+        name
+        // Use the key as the name
+      };
+      registerTool(fullTool);
+      toolNames.push(name);
+    }
+    registeredToolsRef.current = toolNames;
+    return () => {
+      for (const name of registeredToolsRef.current) {
+        unregisterTool(name);
+      }
+      registeredToolsRef.current = [];
+    };
+  }, [toolsKey]);
+}
+function SkillContextInjector({
+  registry,
+  skills
+}) {
+  const catalog = React2.useMemo(() => registry.buildCatalog(), [skills]);
+  const eagerContent = React2.useMemo(() => registry.buildEagerContent(), [skills]);
+  useAIContext({
+    key: "__skill_catalog__",
+    description: "Skills the AI can load on demand",
+    data: catalog ? `You have access to specialized skills. Call load_skill({ name }) when relevant.
+
+${catalog}` : ""
+  });
+  useAIContext({
+    key: "__skill_eager__",
+    description: "Always-active skill instructions",
+    data: eagerContent
+  });
+  return null;
+}
+function SkillRequestSync({ skills }) {
+  const { setInlineSkills } = useCopilot();
+  React2.useEffect(() => {
+    const inlineSkills = skills.filter((s) => s.source.type === "inline").map((s) => ({
+      name: s.name,
+      description: s.description,
+      content: s.content,
+      strategy: s.strategy
+    }));
+    setInlineSkills(inlineSkills);
+  }, [skills, setInlineSkills]);
+  return null;
+}
+function SkillToolRegistrar({
+  registry,
+  skills
+}) {
+  useTool(
+    {
+      name: "load_skill",
+      description: "Load a skill by name to get full instructions for a specialized task.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "The name of the skill to load."
+          }
+        },
+        required: ["name"]
+      },
+      handler: async ({ name }) => {
+        const skill = registry.get(name);
+        if (!skill) {
+          const available = registry.getAuto().map((s) => s.name).join(", ") || "none";
+          return {
+            success: false,
+            error: `Skill "${name}" not found. Available skills: ${available}`
+          };
+        }
+        const sourceTypeMap = {
+          inline: "client-inline",
+          url: "remote-url",
+          file: "server-dir"
+        };
+        return {
+          success: true,
+          name: skill.name,
+          description: skill.description,
+          strategy: skill.strategy ?? "auto",
+          content: skill.content,
+          source: sourceTypeMap[skill.source.type]
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [skills]
+  );
+  return null;
+}
+function SkillProvider({
+  children,
+  skills: skillsProp
+}) {
+  const registryRef = React2.useRef(null);
+  if (registryRef.current === null) {
+    registryRef.current = new chunkBJYA5NDL_cjs.SkillRegistry();
+  }
+  const registry = registryRef.current;
+  const [skills, setSkills] = React2.useState([]);
+  React2.useEffect(() => {
+    if (!skillsProp?.length) return;
+    for (const def of skillsProp) {
+      if (def.source.type !== "inline") {
+        console.warn(
+          `[copilot-sdk/skills] Client-side SkillProvider only supports inline skills. Skill "${def.name}" has source type "${def.source.type}" and will be skipped. Use loadSkills() on the server for file/url skills.`
+        );
+        continue;
+      }
+      const resolved = {
+        ...def,
+        content: def.source.content
+      };
+      registry.register(resolved);
+    }
+    setSkills(registry.getAll());
+    return () => {
+      for (const def of skillsProp ?? []) {
+        registry.unregister(def.name);
       }
-      registeredToolsRef.current = [];
+      setSkills(registry.getAll());
     };
-  }, [
-    autoRegister,
-    mcpClient.isConnected,
-    toolDefinitions,
-    registerTool,
-    unregisterTool
-  ]);
-  return {
-    ...mcpClient,
-    toolDefinitions
-  };
+  }, [skillsProp]);
+  const register = React2.useCallback((skill) => {
+    registry.register(skill);
+    setSkills(registry.getAll());
+  }, []);
+  const unregister = React2.useCallback((name) => {
+    registry.unregister(name);
+    setSkills(registry.getAll());
+  }, []);
+  const contextValue = React2.useMemo(
+    () => ({ registry, register, unregister, skills }),
+    [register, unregister, skills]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(SkillContext.Provider, { value: contextValue, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(SkillContextInjector, { registry, skills }),
+    /* @__PURE__ */ jsxRuntime.jsx(SkillToolRegistrar, { registry, skills }),
+    /* @__PURE__ */ jsxRuntime.jsx(SkillRequestSync, { skills }),
+    children
+  ] });
 }
 function MCPConnection({ config }) {
   useMCPTools({
@@ -2559,9 +5050,126 @@ function MCPConnection({ config }) {
   });
   return null;
 }
-var CopilotContext = react.createContext(null);
+var COMPACTING_MARKER_ID = "__compacting-in-progress__";
+function MessageHistoryBridge({
+  chatRef
+}) {
+  const { compactionState, tokenUsage } = useMessageHistory();
+  const ctx = useMessageHistoryContext();
+  const loaderAddedRef = React2.useRef(false);
+  const prevCompactionCountRef = React2.useRef(compactionState.compactionCount);
+  React2.useEffect(() => {
+    if (!tokenUsage.isApproaching) {
+      loaderAddedRef.current = false;
+      return;
+    }
+    if (loaderAddedRef.current) return;
+    const chat = chatRef.current;
+    if (!chat) return;
+    const alreadyAdded = chat.messages.some(
+      (m) => m.id === COMPACTING_MARKER_ID
+    );
+    if (alreadyAdded) return;
+    loaderAddedRef.current = true;
+    const loading = {
+      id: COMPACTING_MARKER_ID,
+      role: "system",
+      content: "Compacting conversation\u2026",
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata: { type: "compaction-marker", compacting: true }
+    };
+    chat.setMessages([...chat.messages, loading]);
+  }, [tokenUsage.isApproaching]);
+  React2.useEffect(() => {
+    if (compactionState.compactionCount <= prevCompactionCountRef.current)
+      return;
+    prevCompactionCountRef.current = compactionState.compactionCount;
+    loaderAddedRef.current = false;
+    const chat = chatRef.current;
+    if (!chat) return;
+    const hasLoader = chat.messages.some((m) => m.id === COMPACTING_MARKER_ID);
+    const base = hasLoader ? chat.messages.map(
+      (m) => m.id === COMPACTING_MARKER_ID ? {
+        ...m,
+        id: `compaction-marker-${compactionState.compactionCount}`,
+        content: `Conversation compacted \u2014 context window refreshed`,
+        metadata: { type: "compaction-marker", compacting: false }
+      } : m
+    ) : [
+      ...chat.messages,
+      {
+        id: `compaction-marker-${compactionState.compactionCount}`,
+        role: "system",
+        content: `Conversation compacted \u2014 context window refreshed`,
+        createdAt: /* @__PURE__ */ new Date(),
+        metadata: { type: "compaction-marker", compacting: false }
+      }
+    ];
+    chat.setMessages(base);
+  }, [compactionState.compactionCount]);
+  const compactionStateRef = React2.useRef(compactionState);
+  compactionStateRef.current = compactionState;
+  const configRef = React2.useRef(ctx.config);
+  configRef.current = ctx.config;
+  React2.useEffect(() => {
+    const chat = chatRef.current;
+    if (!chat) return;
+    chat.setRequestMessageTransform((allMessages) => {
+      if (allMessages.length === 0) return allMessages;
+      let lastUserIdx = -1;
+      for (let i = allMessages.length - 1; i >= 0; i--) {
+        if (allMessages[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx === -1) return allMessages;
+      const historyMessages = allMessages.slice(0, lastUserIdx);
+      const currentTurn = allMessages.slice(lastUserIdx);
+      if (historyMessages.length === 0) return allMessages;
+      const cfg = configRef.current;
+      const cs = compactionStateRef.current;
+      const recentBuffer = cfg.recentBuffer ?? 10;
+      const isCompactionMsg = (m) => m.metadata?.["type"] === "compaction-marker";
+      const windowedHistory = [];
+      if (cs.workingMemory.length > 0) {
+        windowedHistory.push({
+          id: "working-memory",
+          role: "system",
+          content: `[Working memory \u2014 always active]
+${cs.workingMemory.join("\n")}`,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+      if (cs.rollingSummary) {
+        windowedHistory.push({
+          id: "rolling-summary",
+          role: "system",
+          content: `[Previous conversation summary]
+${cs.rollingSummary}`,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+      const systemMsgs = historyMessages.filter(
+        (m) => m.role === "system" && !isCompactionMsg(m)
+      );
+      windowedHistory.push(...systemMsgs);
+      const conversationMsgs = historyMessages.filter(
+        (m) => m.role !== "system"
+      );
+      const recentStart = Math.max(0, conversationMsgs.length - recentBuffer);
+      windowedHistory.push(...conversationMsgs.slice(recentStart));
+      return [...windowedHistory, ...currentTurn];
+    });
+    return () => {
+      chatRef.current?.setRequestMessageTransform(null);
+    };
+  }, []);
+  return null;
+}
+var CopilotContext = React2.createContext(null);
 function useCopilot() {
-  const context = react.useContext(CopilotContext);
+  const context = React2.useContext(CopilotContext);
   if (!context) {
     throw new Error("useCopilot must be used within CopilotProvider");
   }
@@ -2582,23 +5190,26 @@ function CopilotProvider({
   debug = false,
   maxIterations,
   maxIterationsMessage,
-  mcpServers
+  mcpServers,
+  optimization,
+  messageHistory,
+  skills
 }) {
-  const debugLog = react.useCallback(
-    (...args) => {
-      if (debug) console.log("[Copilot SDK]", ...args);
+  const debugLog = React2.useCallback(
+    (action, data) => {
+      chunkI3SQUNTT_cjs.createLogger("provider", () => debug ?? false)(action, data);
     },
     [debug]
   );
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (toolsConfig && (toolsConfig.screenshot || toolsConfig.console || toolsConfig.network)) {
       console.warn(
         "[Copilot SDK] The `tools` prop is deprecated. Use the `useTools` hook instead."
       );
     }
   }, [toolsConfig]);
-  const [toolExecutions, setToolExecutions] = react.useState([]);
-  const chatRef = react.useRef(null);
+  const [toolExecutions, setToolExecutions] = React2.useState([]);
+  const chatRef = React2.useRef(null);
   if (chatRef.current !== null && chatRef.current.disposed) {
     chatRef.current.revive();
     debugLog("Revived disposed instance (React StrictMode)");
@@ -2626,7 +5237,8 @@ function CopilotProvider({
         body,
         debug,
         maxIterations,
-        maxIterationsMessage
+        maxIterationsMessage,
+        optimization
       },
       {
         onToolExecutionsChange: (executions) => {
@@ -2636,92 +5248,111 @@ function CopilotProvider({
         onApprovalRequired: (execution) => {
           debugLog("Tool approval required:", execution.name);
         },
+        onContextUsageChange: (usage) => {
+          setContextUsage(usage);
+        },
         onError: (error2) => {
           if (error2) onError?.(error2);
         }
       }
     );
   }
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (chatRef.current && systemPrompt !== void 0) {
       chatRef.current.setSystemPrompt(systemPrompt);
       debugLog("System prompt updated from prop");
     }
   }, [systemPrompt, debugLog]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (chatRef.current && headers !== void 0) {
       chatRef.current.setHeaders(headers);
       debugLog("Headers config updated from prop");
     }
   }, [headers, debugLog]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (chatRef.current && body !== void 0) {
       chatRef.current.setBody(body);
       debugLog("Body config updated from prop");
     }
   }, [body, debugLog]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (chatRef.current && runtimeUrl !== void 0) {
       chatRef.current.setUrl(runtimeUrl);
       debugLog("URL config updated from prop");
     }
   }, [runtimeUrl, debugLog]);
-  const messages = react.useSyncExternalStore(
+  const EMPTY_MESSAGES = React2.useRef([]);
+  const getMessagesSnapshot = React2.useCallback(() => chatRef.current.messages, []);
+  const getServerMessagesSnapshot = React2.useCallback(
+    () => EMPTY_MESSAGES.current,
+    []
+  );
+  const getStatusSnapshot = React2.useCallback(() => chatRef.current.status, []);
+  const getErrorSnapshot = React2.useCallback(() => chatRef.current.error, []);
+  const messages = React2.useSyncExternalStore(
     chatRef.current.subscribe,
-    () => chatRef.current.messages,
-    () => chatRef.current.messages
+    getMessagesSnapshot,
+    getServerMessagesSnapshot
   );
-  const status = react.useSyncExternalStore(
+  const status = React2.useSyncExternalStore(
     chatRef.current.subscribe,
-    () => chatRef.current.status,
+    getStatusSnapshot,
     () => "ready"
   );
-  const errorFromChat = react.useSyncExternalStore(
+  const errorFromChat = React2.useSyncExternalStore(
     chatRef.current.subscribe,
-    () => chatRef.current.error,
+    getErrorSnapshot,
     () => void 0
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
-  const registerTool = react.useCallback((tool2) => {
+  const registerTool = React2.useCallback((tool2) => {
     chatRef.current?.registerTool(tool2);
   }, []);
-  const unregisterTool = react.useCallback((name) => {
+  const unregisterTool = React2.useCallback((name) => {
     chatRef.current?.unregisterTool(name);
   }, []);
-  const approveToolExecution = react.useCallback(
+  const approveToolExecution = React2.useCallback(
     (id, extraData, permissionLevel) => {
       chatRef.current?.approveToolExecution(id, extraData, permissionLevel);
     },
     []
   );
-  const rejectToolExecution = react.useCallback(
+  const rejectToolExecution = React2.useCallback(
     (id, reason, permissionLevel) => {
       chatRef.current?.rejectToolExecution(id, reason, permissionLevel);
     },
     []
   );
-  const registeredTools = chatRef.current?.tools ?? [];
-  const pendingApprovals = toolExecutions.filter(
-    (e) => e.approvalStatus === "required"
+  const registeredTools = React2.useMemo(
+    () => chatRef.current?.tools ?? [],
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [toolExecutions]
+    // re-derive when tool executions change (tools change alongside)
   );
-  const actionsRef = react.useRef(/* @__PURE__ */ new Map());
-  const [actionsVersion, setActionsVersion] = react.useState(0);
-  const registerAction = react.useCallback((action) => {
+  const pendingApprovals = React2.useMemo(
+    () => toolExecutions.filter((e) => e.approvalStatus === "required"),
+    [toolExecutions]
+  );
+  const actionsRef = React2.useRef(/* @__PURE__ */ new Map());
+  const [actionsVersion, setActionsVersion] = React2.useState(0);
+  const registerAction = React2.useCallback((action) => {
     actionsRef.current.set(action.name, action);
     setActionsVersion((v) => v + 1);
   }, []);
-  const unregisterAction = react.useCallback((name) => {
+  const unregisterAction = React2.useCallback((name) => {
     actionsRef.current.delete(name);
     setActionsVersion((v) => v + 1);
   }, []);
-  const registeredActions = react.useMemo(
+  const registeredActions = React2.useMemo(
     () => Array.from(actionsRef.current.values()),
     [actionsVersion]
   );
-  const contextTreeRef = react.useRef([]);
-  const contextIdCounter = react.useRef(0);
-  const addContext = react.useCallback(
+  const contextTreeRef = React2.useRef([]);
+  const contextIdCounter = React2.useRef(0);
+  const [contextChars, setContextChars] = React2.useState(0);
+  const [contextUsage, setContextUsage] = React2.useState(null);
+  const addContext = React2.useCallback(
     (context, parentId) => {
       const id = `ctx-${++contextIdCounter.current}`;
       contextTreeRef.current = addNode(
@@ -2731,55 +5362,95 @@ function CopilotProvider({
       );
       const contextString = printTree(contextTreeRef.current);
       chatRef.current?.setContext(contextString);
+      setContextChars(contextString.length);
       debugLog("Context added:", id);
       return id;
     },
     [debugLog]
   );
-  const removeContext = react.useCallback(
+  const removeContext = React2.useCallback(
     (id) => {
       contextTreeRef.current = removeNode(contextTreeRef.current, id);
       const contextString = printTree(contextTreeRef.current);
       chatRef.current?.setContext(contextString);
+      setContextChars(contextString.length);
       debugLog("Context removed:", id);
     },
     [debugLog]
   );
-  const setSystemPrompt = react.useCallback(
+  const setSystemPrompt = React2.useCallback(
     (prompt) => {
       chatRef.current?.setSystemPrompt(prompt);
       debugLog("System prompt updated via function");
     },
     [debugLog]
   );
-  const sendMessage = react.useCallback(
+  const setInlineSkills = React2.useCallback(
+    (skills2) => {
+      chatRef.current?.setInlineSkills(skills2);
+      debugLog("Inline skills updated", { count: skills2.length });
+    },
+    [debugLog]
+  );
+  const sendMessage = React2.useCallback(
     async (content, attachments) => {
       debugLog("Sending message:", content);
       await chatRef.current?.sendMessage(content, attachments);
     },
     [debugLog]
   );
-  const stop = react.useCallback(() => {
+  const stop = React2.useCallback(() => {
     chatRef.current?.stop();
   }, []);
-  const clearMessages = react.useCallback(() => {
+  const clearMessages = React2.useCallback(() => {
     chatRef.current?.clearMessages();
   }, []);
-  const setMessages = react.useCallback((messages2) => {
+  const setMessages = React2.useCallback((messages2) => {
     chatRef.current?.setMessages(messages2);
   }, []);
-  const regenerate = react.useCallback(async (messageId) => {
+  const regenerate = React2.useCallback(async (messageId) => {
     await chatRef.current?.regenerate(messageId);
   }, []);
-  react.useEffect(() => {
+  const switchBranch = React2.useCallback((messageId) => {
+    chatRef.current?.switchBranch(messageId);
+  }, []);
+  const getBranchInfo = React2.useCallback(
+    (messageId) => chatRef.current?.getBranchInfo(messageId) ?? null,
+    []
+  );
+  const editMessage = React2.useCallback(
+    async (messageId, newContent) => {
+      await chatRef.current?.sendMessage(newContent, void 0, {
+        editMessageId: messageId
+      });
+    },
+    []
+  );
+  const getHasBranchesSnapshot = React2.useCallback(
+    () => chatRef.current.hasBranches,
+    []
+  );
+  const hasBranches = React2.useSyncExternalStore(
+    chatRef.current.subscribe,
+    getHasBranchesSnapshot,
+    () => false
+  );
+  const getAllMessages = React2.useCallback(
+    () => chatRef.current?.getAllMessages?.() ?? [],
+    []
+  );
+  React2.useEffect(() => {
     if (onMessagesChange && messages.length > 0) {
-      const coreMessages = messages.map((m) => ({
+      const allUIMessages = chatRef.current?.getAllMessages?.() ?? messages;
+      const coreMessages = allUIMessages.map((m) => ({
         id: m.id,
         role: m.role,
         content: m.content,
         created_at: m.createdAt,
         tool_calls: m.toolCalls,
         tool_call_id: m.toolCallId,
+        parent_id: m.parentId,
+        children_ids: m.childrenIds,
         metadata: {
           attachments: m.attachments,
           thinking: m.thinking
@@ -2788,17 +5459,17 @@ function CopilotProvider({
       onMessagesChange(coreMessages);
     }
   }, [messages, onMessagesChange]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (error && onError) {
       onError(error);
     }
   }, [error, onError]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     return () => {
       chatRef.current?.dispose();
     };
   }, []);
-  const contextValue = react.useMemo(
+  const contextValue = React2.useMemo(
     () => ({
       // Chat state
       messages,
@@ -2811,6 +5482,12 @@ function CopilotProvider({
       clearMessages,
       setMessages,
       regenerate,
+      // Branching
+      switchBranch,
+      getBranchInfo,
+      editMessage,
+      hasBranches,
+      getAllMessages,
       // Tool execution
       registerTool,
       unregisterTool,
@@ -2826,8 +5503,12 @@ function CopilotProvider({
       // AI Context
       addContext,
       removeContext,
+      contextChars,
+      contextUsage,
       // System Prompt
       setSystemPrompt,
+      // Skills
+      setInlineSkills,
       // Config
       threadId,
       runtimeUrl,
@@ -2843,6 +5524,11 @@ function CopilotProvider({
       clearMessages,
       setMessages,
       regenerate,
+      switchBranch,
+      getBranchInfo,
+      editMessage,
+      hasBranches,
+      getAllMessages,
       registerTool,
       unregisterTool,
       registeredTools,
@@ -2855,20 +5541,45 @@ function CopilotProvider({
       registeredActions,
       addContext,
       removeContext,
+      contextChars,
+      contextUsage,
       setSystemPrompt,
+      setInlineSkills,
       threadId,
       runtimeUrl,
       toolsConfig
     ]
   );
-  return /* @__PURE__ */ jsxRuntime.jsxs(CopilotContext.Provider, { value: contextValue, children: [
+  const messageHistoryContextValue = React2__default.default.useMemo(
+    () => ({
+      config: { ...defaultMessageHistoryConfig, ...messageHistory },
+      tokenUsage: {
+        current: 0,
+        max: messageHistory?.maxContextTokens ?? 128e3,
+        percentage: 0,
+        isApproaching: false
+      },
+      compactionState: {
+        rollingSummary: null,
+        lastCompactionAt: null,
+        compactionCount: 0,
+        totalTokensSaved: 0,
+        workingMemory: [],
+        displayMessageCount: 0,
+        llmMessageCount: 0
+      }
+    }),
+    [messageHistory]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryContext.Provider, { value: messageHistoryContextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(CopilotContext.Provider, { value: contextValue, children: [
     mcpServers?.map((config) => /* @__PURE__ */ jsxRuntime.jsx(MCPConnection, { config }, config.name)),
-    children
-  ] });
+    messageHistory?.strategy && messageHistory.strategy !== "none" && /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryBridge, { chatRef }),
+    skills ? /* @__PURE__ */ jsxRuntime.jsx(SkillProvider, { skills, children }) : children
+  ] }) });
 }
 function useAIActions(actions) {
   const { registerAction, unregisterAction } = useCopilot();
-  react.useEffect(() => {
+  React2.useEffect(() => {
     for (const action of actions) {
       registerAction(action);
     }
@@ -2882,61 +5593,6 @@ function useAIActions(actions) {
 function useAIAction(action) {
   useAIActions([action]);
 }
-function useAIContext(item) {
-  const { addContext, removeContext } = useCopilot();
-  const contextIdRef = react.useRef(null);
-  const serializedData = typeof item.data === "string" ? item.data : JSON.stringify(item.data);
-  react.useEffect(() => {
-    const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
-    const contextString = item.description ? `${item.description}:
-${formattedValue}` : `${item.key}:
-${formattedValue}`;
-    contextIdRef.current = addContext(contextString, item.parentId);
-    return () => {
-      if (contextIdRef.current) {
-        removeContext(contextIdRef.current);
-        contextIdRef.current = null;
-      }
-    };
-  }, [
-    item.key,
-    serializedData,
-    item.description,
-    item.parentId,
-    addContext,
-    removeContext
-  ]);
-  return contextIdRef.current ?? void 0;
-}
-function useAIContexts(items) {
-  const { addContext, removeContext } = useCopilot();
-  const contextIdsRef = react.useRef([]);
-  const serializedItems = JSON.stringify(
-    items.map((item) => ({
-      key: item.key,
-      data: item.data,
-      description: item.description,
-      parentId: item.parentId
-    }))
-  );
-  react.useEffect(() => {
-    contextIdsRef.current.forEach((id) => removeContext(id));
-    contextIdsRef.current = [];
-    const parsedItems = JSON.parse(serializedItems);
-    for (const item of parsedItems) {
-      const formattedValue = typeof item.data === "string" ? item.data : JSON.stringify(item.data, null, 2);
-      const contextString = item.description ? `${item.description}:
-${formattedValue}` : `${item.key}:
-${formattedValue}`;
-      const id = addContext(contextString, item.parentId);
-      contextIdsRef.current.push(id);
-    }
-    return () => {
-      contextIdsRef.current.forEach((id) => removeContext(id));
-      contextIdsRef.current = [];
-    };
-  }, [serializedItems, addContext, removeContext]);
-}
 function useAITools(options = {}) {
   const {
     screenshot = false,
@@ -2949,27 +5605,27 @@ function useAITools(options = {}) {
     onConsentRequest,
     autoStart = true
   } = options;
-  const [isEnabled] = react.useState(screenshot || consoleCapture || network);
-  const [activeCaptures, setActiveCaptures] = react.useState({
+  const [isEnabled] = React2.useState(screenshot || consoleCapture || network);
+  const [activeCaptures, setActiveCaptures] = React2.useState({
     console: false,
     network: false
   });
-  const [pendingConsent, setPendingConsent] = react.useState(null);
-  const consentResolverRef = react.useRef(null);
-  const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
-  react.useEffect(() => {
+  const [pendingConsent, setPendingConsent] = React2.useState(null);
+  const consentResolverRef = React2.useRef(null);
+  const rememberedConsentRef = React2.useRef(/* @__PURE__ */ new Set());
+  React2.useEffect(() => {
     if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunkOQPRIB73_cjs.isConsoleCaptureActive()) {
-      chunkOQPRIB73_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunkI3SQUNTT_cjs.isConsoleCaptureActive()) {
+      chunkI3SQUNTT_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkOQPRIB73_cjs.isNetworkCaptureActive()) {
-      chunkOQPRIB73_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkI3SQUNTT_cjs.isNetworkCaptureActive()) {
+      chunkI3SQUNTT_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
     return () => {
-      chunkOQPRIB73_cjs.stopConsoleCapture();
-      chunkOQPRIB73_cjs.stopNetworkCapture();
+      chunkI3SQUNTT_cjs.stopConsoleCapture();
+      chunkI3SQUNTT_cjs.stopNetworkCapture();
     };
   }, [
     autoStart,
@@ -2979,39 +5635,39 @@ function useAITools(options = {}) {
     consoleOptions,
     networkOptions
   ]);
-  const captureScreenshotFn = react.useCallback(
+  const captureScreenshotFn = React2.useCallback(
     async (opts) => {
       if (!screenshot) {
         throw new Error("Screenshot capture is not enabled");
       }
-      if (!chunkOQPRIB73_cjs.isScreenshotSupported()) {
+      if (!chunkI3SQUNTT_cjs.isScreenshotSupported()) {
         throw new Error(
           "Screenshot capture is not supported in this environment"
         );
       }
-      return chunkOQPRIB73_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+      return chunkI3SQUNTT_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
     },
     [screenshot, screenshotOptions]
   );
-  const getConsoleLogsFn = react.useCallback(
+  const getConsoleLogsFn = React2.useCallback(
     (opts) => {
       if (!consoleCapture) {
         return { logs: [], totalCaptured: 0 };
       }
-      return chunkOQPRIB73_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+      return chunkI3SQUNTT_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
     },
     [consoleCapture, consoleOptions]
   );
-  const getNetworkRequestsFn = react.useCallback(
+  const getNetworkRequestsFn = React2.useCallback(
     (opts) => {
       if (!network) {
         return { requests: [], totalCaptured: 0 };
       }
-      return chunkOQPRIB73_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+      return chunkI3SQUNTT_cjs.getNetworkRequests({ ...networkOptions, ...opts });
     },
     [network, networkOptions]
   );
-  const requestConsent = react.useCallback(
+  const requestConsent = React2.useCallback(
     async (tools, reason = "") => {
       const enabledTools = tools.filter((tool2) => {
         if (tool2 === "screenshot") return screenshot;
@@ -3059,14 +5715,14 @@ function useAITools(options = {}) {
     },
     [screenshot, consoleCapture, network, requireConsent, onConsentRequest]
   );
-  const respondToConsent = react.useCallback((response) => {
+  const respondToConsent = React2.useCallback((response) => {
     if (consentResolverRef.current) {
       consentResolverRef.current(response);
       consentResolverRef.current = null;
     }
     setPendingConsent(null);
   }, []);
-  const captureContext = react.useCallback(
+  const captureContext = React2.useCallback(
     async (tools) => {
       const toolsToCapture = tools || ["screenshot", "console", "network"];
       const context = {
@@ -3099,26 +5755,26 @@ function useAITools(options = {}) {
       getNetworkRequestsFn
     ]
   );
-  const startCapturing = react.useCallback(() => {
-    if (consoleCapture && !chunkOQPRIB73_cjs.isConsoleCaptureActive()) {
-      chunkOQPRIB73_cjs.startConsoleCapture(consoleOptions);
+  const startCapturing = React2.useCallback(() => {
+    if (consoleCapture && !chunkI3SQUNTT_cjs.isConsoleCaptureActive()) {
+      chunkI3SQUNTT_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkOQPRIB73_cjs.isNetworkCaptureActive()) {
-      chunkOQPRIB73_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkI3SQUNTT_cjs.isNetworkCaptureActive()) {
+      chunkI3SQUNTT_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
   }, [consoleCapture, network, consoleOptions, networkOptions]);
-  const stopCapturing = react.useCallback(() => {
-    chunkOQPRIB73_cjs.stopConsoleCapture();
-    chunkOQPRIB73_cjs.stopNetworkCapture();
+  const stopCapturing = React2.useCallback(() => {
+    chunkI3SQUNTT_cjs.stopConsoleCapture();
+    chunkI3SQUNTT_cjs.stopNetworkCapture();
     setActiveCaptures({ console: false, network: false });
   }, []);
-  const clearCaptured = react.useCallback(() => {
-    chunkOQPRIB73_cjs.clearConsoleLogs();
-    chunkOQPRIB73_cjs.clearNetworkRequests();
+  const clearCaptured = React2.useCallback(() => {
+    chunkI3SQUNTT_cjs.clearConsoleLogs();
+    chunkI3SQUNTT_cjs.clearNetworkRequests();
   }, []);
-  const formatForAI = react.useCallback((context) => {
+  const formatForAI = React2.useCallback((context) => {
     const parts = [];
     if (context.screenshot) {
       parts.push(
@@ -3126,16 +5782,16 @@ function useAITools(options = {}) {
       );
     }
     if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunkOQPRIB73_cjs.formatLogsForAI(context.consoleLogs.logs));
+      parts.push(chunkI3SQUNTT_cjs.formatLogsForAI(context.consoleLogs.logs));
     }
     if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunkOQPRIB73_cjs.formatRequestsForAI(context.networkRequests.requests));
+      parts.push(chunkI3SQUNTT_cjs.formatRequestsForAI(context.networkRequests.requests));
     }
     return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
   }, []);
-  const detectIntentFn = react.useCallback(
+  const detectIntentFn = React2.useCallback(
     (message) => {
-      const result = chunkOQPRIB73_cjs.detectIntent(message);
+      const result = chunkI3SQUNTT_cjs.detectIntent(message);
       result.suggestedTools = result.suggestedTools.filter((tool2) => {
         if (tool2 === "screenshot") return screenshot;
         if (tool2 === "console") return consoleCapture;
@@ -3146,7 +5802,7 @@ function useAITools(options = {}) {
     },
     [screenshot, consoleCapture, network]
   );
-  return react.useMemo(
+  return React2.useMemo(
     () => ({
       isEnabled,
       activeCaptures,
@@ -3181,69 +5837,6 @@ function useAITools(options = {}) {
     ]
   );
 }
-function isZodSchema(value) {
-  if (value === null || typeof value !== "object") return false;
-  const obj = value;
-  return "_def" in obj && typeof obj._def === "object" || "_zod" in obj && typeof obj._zod === "object" || "~standard" in obj;
-}
-function useTool(config, dependencies = []) {
-  const { registerTool, unregisterTool } = useCopilot();
-  const configRef = react.useRef(config);
-  configRef.current = config;
-  const inputSchema = react.useMemo(() => {
-    if (isZodSchema(config.inputSchema)) {
-      return chunkOQPRIB73_cjs.zodToJsonSchema(config.inputSchema);
-    }
-    return config.inputSchema;
-  }, [config.inputSchema]);
-  react.useEffect(() => {
-    const tool2 = {
-      name: config.name,
-      description: config.description,
-      location: "client",
-      inputSchema,
-      handler: async (params, context) => {
-        return configRef.current.handler(params, context);
-      },
-      render: config.render,
-      available: config.available ?? true,
-      needsApproval: config.needsApproval,
-      approvalMessage: config.approvalMessage,
-      hidden: config.hidden
-    };
-    registerTool(tool2);
-    return () => {
-      unregisterTool(config.name);
-    };
-  }, [config.name, inputSchema, ...dependencies]);
-}
-function useTools(tools) {
-  const { registerTool, unregisterTool } = useCopilot();
-  const registeredToolsRef = react.useRef([]);
-  const toolsRef = react.useRef(tools);
-  toolsRef.current = tools;
-  const toolsKey = Object.keys(tools).sort().join(",");
-  react.useEffect(() => {
-    const currentTools = toolsRef.current;
-    const toolNames = [];
-    for (const [name, toolDef] of Object.entries(currentTools)) {
-      const fullTool = {
-        ...toolDef,
-        name
-        // Use the key as the name
-      };
-      registerTool(fullTool);
-      toolNames.push(name);
-    }
-    registeredToolsRef.current = toolNames;
-    return () => {
-      for (const name of registeredToolsRef.current) {
-        unregisterTool(name);
-      }
-      registeredToolsRef.current = [];
-    };
-  }, [toolsKey]);
-}
 function convertZodSchema(schema, _toolName) {
   try {
     const zodWithJsonSchema = z__namespace;
@@ -3261,13 +5854,13 @@ function convertZodSchema(schema, _toolName) {
     }
   } catch {
   }
-  return chunkOQPRIB73_cjs.zodObjectToInputSchema(schema);
+  return chunkI3SQUNTT_cjs.zodObjectToInputSchema(schema);
 }
 function useToolWithSchema(config, dependencies = []) {
   const { registerTool, unregisterTool } = useCopilot();
-  const configRef = react.useRef(config);
+  const configRef = React2.useRef(config);
   configRef.current = config;
-  const inputSchema = react.useMemo(() => {
+  const inputSchema = React2.useMemo(() => {
     try {
       return convertZodSchema(config.schema, config.name);
     } catch (error) {
@@ -3281,7 +5874,7 @@ function useToolWithSchema(config, dependencies = []) {
       };
     }
   }, [config.schema, config.name]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     const tool2 = {
       name: config.name,
       description: config.description,
@@ -3301,9 +5894,9 @@ function useToolWithSchema(config, dependencies = []) {
 }
 function useToolsWithSchema(tools, dependencies = []) {
   const { registerTool, unregisterTool } = useCopilot();
-  const toolsRef = react.useRef(tools);
+  const toolsRef = React2.useRef(tools);
   toolsRef.current = tools;
-  react.useEffect(() => {
+  React2.useEffect(() => {
     const toolNames = [];
     for (const config of tools) {
       let inputSchema;
@@ -3342,9 +5935,9 @@ function useToolsWithSchema(tools, dependencies = []) {
     };
   }, [tools.map((t) => t.name).join(","), ...dependencies]);
 }
-var CopilotContext2 = react.createContext(null);
+var CopilotContext2 = React2.createContext(null);
 function useCopilotContext() {
-  const context = react.useContext(CopilotContext2);
+  const context = React2.useContext(CopilotContext2);
   if (!context) {
     throw new Error("useCopilotContext must be used within a CopilotProvider");
   }
@@ -3360,9 +5953,9 @@ function useToolExecutor() {
     addToolExecution,
     updateToolExecution
   } = useCopilotContext();
-  const toolsRef = react.useRef(registeredTools);
+  const toolsRef = React2.useRef(registeredTools);
   toolsRef.current = registeredTools;
-  const executeTool = react.useCallback(
+  const executeTool = React2.useCallback(
     async (toolCall) => {
       const tool2 = toolsRef.current.find((t) => t.name === toolCall.name);
       if (!tool2) {
@@ -3412,7 +6005,7 @@ function useToolExecutor() {
     },
     [addToolExecution, updateToolExecution]
   );
-  const sendToolResult = react.useCallback(
+  const sendToolResult = React2.useCallback(
     async (toolCallId, result) => {
       const runtimeUrl = config.runtimeUrl || config.cloud?.endpoint;
       if (!runtimeUrl) {
@@ -3446,10 +6039,10 @@ function useToolExecutor() {
     },
     [config.runtimeUrl, config.cloud?.endpoint, chat.threadId]
   );
-  const getTool = react.useCallback((name) => {
+  const getTool = React2.useCallback((name) => {
     return toolsRef.current.find((t) => t.name === name);
   }, []);
-  const hasTool = react.useCallback((name) => {
+  const hasTool = React2.useCallback((name) => {
     return toolsRef.current.some((t) => t.name === name);
   }, []);
   return {
@@ -3467,13 +6060,13 @@ function useSuggestions(options = {}) {
     autoRefresh = true
   } = options;
   const { chat, actions, config } = useCopilotContext();
-  const [suggestions, setSuggestions] = react.useState([]);
-  const [isLoading, setIsLoading] = react.useState(false);
-  const normalizedStatic = react.useMemo(
+  const [suggestions, setSuggestions] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const normalizedStatic = React2.useMemo(
     () => staticSuggestions?.map((s) => typeof s === "string" ? { text: s } : s),
     [staticSuggestions]
   );
-  const refresh = react.useCallback(async () => {
+  const refresh = React2.useCallback(async () => {
     if (normalizedStatic) {
       setSuggestions(normalizedStatic.slice(0, count));
       return;
@@ -3512,14 +6105,14 @@ function useSuggestions(options = {}) {
       setIsLoading(false);
     }
   }, [config.cloud, count, context, chat.messages, normalizedStatic]);
-  const select = react.useCallback(
+  const select = React2.useCallback(
     (suggestion) => {
       const text = typeof suggestion === "string" ? suggestion : suggestion.text;
       actions.sendMessage(text);
     },
     [actions]
   );
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (autoRefresh && chat.messages.length === 0) {
       refresh();
     }
@@ -3534,18 +6127,18 @@ function useSuggestions(options = {}) {
 function useAgent(options) {
   const { name, initialState = {}, onStateChange } = options;
   const { config } = useCopilotContext();
-  const [state, setStateInternal] = react.useState(initialState);
-  const [isRunning, setIsRunning] = react.useState(false);
-  const [nodeName, setNodeName] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  const abortControllerRef = react.useRef(null);
-  const getEndpoint = react.useCallback(() => {
+  const [state, setStateInternal] = React2.useState(initialState);
+  const [isRunning, setIsRunning] = React2.useState(false);
+  const [nodeName, setNodeName] = React2.useState(null);
+  const [error, setError] = React2.useState(null);
+  const abortControllerRef = React2.useRef(null);
+  const getEndpoint = React2.useCallback(() => {
     if (config.cloud) {
       return `${config.cloud.endpoint || "https://api.yourgpt.ai/v1"}/agents/${name}`;
     }
     return `${config.runtimeUrl || "/api"}/agents/${name}`;
   }, [config, name]);
-  const start = react.useCallback(
+  const start = React2.useCallback(
     async (input) => {
       setIsRunning(true);
       setError(null);
@@ -3570,7 +6163,7 @@ function useAgent(options) {
         if (!response.ok) {
           throw new Error(`Agent error: ${response.status}`);
         }
-        for await (const event of chunkOQPRIB73_cjs.streamSSE(response)) {
+        for await (const event of chunkI3SQUNTT_cjs.streamSSE(response)) {
           handleAgentEvent(event);
         }
       } catch (err) {
@@ -3584,7 +6177,7 @@ function useAgent(options) {
     },
     [config, getEndpoint, state]
   );
-  const handleAgentEvent = react.useCallback(
+  const handleAgentEvent = React2.useCallback(
     (event) => {
       if (event.type === "error") {
         setError(new Error(event.message));
@@ -3600,10 +6193,10 @@ function useAgent(options) {
     },
     [onStateChange]
   );
-  const stop = react.useCallback(() => {
+  const stop = React2.useCallback(() => {
     abortControllerRef.current?.abort();
   }, []);
-  const setState = react.useCallback(
+  const setState = React2.useCallback(
     (partialState) => {
       setStateInternal((prev) => {
         const newState = { ...prev, ...partialState };
@@ -3613,7 +6206,7 @@ function useAgent(options) {
     },
     [onStateChange]
   );
-  react.useEffect(() => {
+  React2.useEffect(() => {
     return () => {
       abortControllerRef.current?.abort();
     };
@@ -3694,9 +6287,9 @@ function formatKnowledgeResultsForAI(results) {
 // src/react/hooks/useKnowledgeBase.ts
 function useKnowledgeBase(config) {
   const { registerTool, unregisterTool } = useCopilot();
-  const configRef = react.useRef(config);
+  const configRef = React2.useRef(config);
   configRef.current = config;
-  const handleSearch = react.useCallback(
+  const handleSearch = React2.useCallback(
     async (params) => {
       const query = params.query;
       if (!query) {
@@ -3734,7 +6327,7 @@ function useKnowledgeBase(config) {
     },
     []
   );
-  react.useEffect(() => {
+  React2.useEffect(() => {
     if (config.enabled === false) {
       return;
     }
@@ -3781,14 +6374,14 @@ var DEFAULT_CAPABILITIES = {
 };
 function useCapabilities() {
   const { config } = useCopilotContext();
-  const [capabilities, setCapabilities] = react.useState(DEFAULT_CAPABILITIES);
-  const [provider, setProvider] = react.useState("unknown");
-  const [model, setModel] = react.useState("unknown");
-  const [supportedModels, setSupportedModels] = react.useState([]);
-  const [isLoading, setIsLoading] = react.useState(true);
-  const [error, setError] = react.useState(null);
+  const [capabilities, setCapabilities] = React2.useState(DEFAULT_CAPABILITIES);
+  const [provider, setProvider] = React2.useState("unknown");
+  const [model, setModel] = React2.useState("unknown");
+  const [supportedModels, setSupportedModels] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
   const capabilitiesUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/chat\/?$/, "/capabilities") : null;
-  const fetchCapabilities = react.useCallback(async () => {
+  const fetchCapabilities = React2.useCallback(async () => {
     if (!capabilitiesUrl) {
       setIsLoading(false);
       return;
@@ -3811,7 +6404,7 @@ function useCapabilities() {
       setIsLoading(false);
     }
   }, [capabilitiesUrl]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     fetchCapabilities();
   }, [fetchCapabilities]);
   return {
@@ -3854,7 +6447,7 @@ function useSupportedMediaTypes() {
 }
 function useDevLogger() {
   const ctx = useCopilotContext();
-  return react.useMemo(() => {
+  return React2.useMemo(() => {
     const toolExecutions = (ctx.agentLoop?.toolExecutions || []).map(
       (exec) => ({
         id: exec.id,
@@ -4064,7 +6657,7 @@ function createReactThreadManagerState(initialThreads) {
 }
 
 // src/react/internal/ReactThreadManager.ts
-var _ReactThreadManager = class _ReactThreadManager extends chunkOQPRIB73_cjs.ThreadManager {
+var _ReactThreadManager = class _ReactThreadManager extends chunkI3SQUNTT_cjs.ThreadManager {
   constructor(config = {}, callbacks = {}) {
     const reactState = new ReactThreadManagerState();
     super({ ...config, state: reactState }, callbacks);
@@ -4200,7 +6793,7 @@ function getInternalManager(config) {
   return internalManager;
 }
 function useThreadManager(config) {
-  const manager = react.useMemo(() => {
+  const manager = React2.useMemo(() => {
     if (!config) {
       return getDefaultManager();
     }
@@ -4223,50 +6816,50 @@ function useThreadManager(config) {
     config?.autoRestoreLastThread
     // Note: callbacks are intentionally not in deps to avoid recreating manager
   ]);
-  const threads = react.useSyncExternalStore(
+  const threads = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getThreadsSnapshot,
     manager.getThreadsServerSnapshot
     // SSR - always empty array
   );
-  const currentThread = react.useSyncExternalStore(
+  const currentThread = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getCurrentThreadSnapshot,
     manager.getCurrentThreadServerSnapshot
     // SSR - always null
   );
-  const currentThreadId = react.useSyncExternalStore(
+  const currentThreadId = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getCurrentThreadIdSnapshot,
     manager.getCurrentThreadIdServerSnapshot
     // SSR - always null
   );
-  const loadStatus = react.useSyncExternalStore(
+  const loadStatus = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getLoadStatusSnapshot,
     manager.getLoadStatusServerSnapshot
     // SSR - always "idle"
   );
-  const error = react.useSyncExternalStore(
+  const error = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getErrorSnapshot,
     manager.getErrorServerSnapshot
     // SSR - always undefined
   );
-  const isLoading = react.useSyncExternalStore(
+  const isLoading = React2.useSyncExternalStore(
     manager.subscribe,
     manager.getIsLoadingSnapshot,
     manager.getIsLoadingServerSnapshot
     // SSR - always false
   );
-  react.useEffect(() => {
+  React2.useEffect(() => {
     return () => {
       if (config?.adapter && manager !== defaultManager && manager !== internalManager) {
         manager.dispose();
       }
     };
   }, [manager, config]);
-  react.useEffect(() => {
+  React2.useEffect(() => {
     const handleBeforeUnload = () => {
       if (manager.hasPendingChanges) {
         manager.saveNow().catch(() => {
@@ -4280,37 +6873,37 @@ function useThreadManager(config) {
       };
     }
   }, [manager]);
-  const createThread = react.useCallback(
+  const createThread = React2.useCallback(
     (options) => manager.createThread(options),
     [manager]
   );
-  const switchThread = react.useCallback(
+  const switchThread = React2.useCallback(
     (id) => manager.switchThread(id),
     [manager]
   );
-  const updateCurrentThread = react.useCallback(
+  const updateCurrentThread = React2.useCallback(
     (updates) => manager.updateCurrentThread(updates),
     [manager]
   );
-  const deleteThread = react.useCallback(
+  const deleteThread = React2.useCallback(
     (id) => manager.deleteThread(id),
     [manager]
   );
-  const clearCurrentThread = react.useCallback(
+  const clearCurrentThread = React2.useCallback(
     () => manager.clearCurrentThread(),
     [manager]
   );
-  const refreshThreads = react.useCallback(() => manager.loadThreads(), [manager]);
-  const saveNow = react.useCallback(() => manager.saveNow(), [manager]);
-  const clearAllThreads = react.useCallback(
+  const refreshThreads = React2.useCallback(() => manager.loadThreads(), [manager]);
+  const saveNow = React2.useCallback(() => manager.saveNow(), [manager]);
+  const clearAllThreads = React2.useCallback(
     () => manager.clearAllThreads(),
     [manager]
   );
-  const messages = react.useMemo(
+  const messages = React2.useMemo(
     () => currentThread?.messages ?? [],
     [currentThread]
   );
-  const setMessages = react.useCallback(
+  const setMessages = React2.useCallback(
     (newMessages) => updateCurrentThread({ messages: newMessages }),
     [updateCurrentThread]
   );
@@ -4347,7 +6940,7 @@ function useMCPUIIntents(config = {}) {
     onLink,
     requireConsent = { tool: false, link: true }
   } = config;
-  const handleIntent = react.useCallback(
+  const handleIntent = React2.useCallback(
     async (intent, context) => {
       switch (intent.type) {
         case "tool": {
@@ -4401,7 +6994,7 @@ function useMCPUIIntents(config = {}) {
     },
     [onToolCall, onIntent, onPrompt, onNotify, onLink, requireConsent]
   );
-  return react.useMemo(
+  return React2.useMemo(
     () => ({
       handleIntent
     }),
@@ -4431,6 +7024,94 @@ function createToolIntentHandler(callTool) {
     }
   };
 }
+function getLastResponseUsage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "assistant" && msg.metadata?.usage) {
+      const u = msg.metadata.usage;
+      const prompt = u.prompt_tokens ?? 0;
+      const completion = u.completion_tokens ?? 0;
+      return {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: u.total_tokens ?? prompt + completion
+      };
+    }
+  }
+  return null;
+}
+function useContextStats() {
+  const { contextChars, contextUsage, registeredTools, messages } = useCopilot();
+  const toolCount = React2.useMemo(() => registeredTools.length, [registeredTools]);
+  const messageCount = React2.useMemo(
+    () => messages.filter((m) => m.role !== "system").length,
+    [messages]
+  );
+  const totalTokens = React2.useMemo(() => {
+    if (contextUsage) return contextUsage.total.tokens;
+    return Math.ceil(contextChars / 3.5);
+  }, [contextUsage, contextChars]);
+  const usagePercent = React2.useMemo(() => {
+    if (contextUsage) return contextUsage.total.percent;
+    return 0;
+  }, [contextUsage]);
+  const lastResponseUsage = React2.useMemo(
+    () => getLastResponseUsage(messages),
+    [messages]
+  );
+  return {
+    contextUsage,
+    totalTokens,
+    usagePercent,
+    contextChars,
+    toolCount,
+    messageCount,
+    lastResponseUsage
+  };
+}
+var DEV_CONTENT_WARN_THRESHOLD = 2e3;
+function useSkill(skill) {
+  const { register, unregister } = useSkillContext();
+  if (process.env.NODE_ENV !== "production" && skill.source.type === "inline" && skill.source.content.length > DEV_CONTENT_WARN_THRESHOLD) {
+    console.warn(
+      `[copilot-sdk/skills] Inline skill "${skill.name}" has ${skill.source.content.length} characters. Inline skills are sent on every request \u2014 keep them under ${DEV_CONTENT_WARN_THRESHOLD} characters. Consider using a file or URL skill instead.`
+    );
+  }
+  React2.useEffect(() => {
+    if (skill.source.type !== "inline") {
+      console.warn(
+        `[copilot-sdk/skills] useSkill only supports inline skills client-side. Skill "${skill.name}" has source type "${skill.source.type}" and will be skipped.`
+      );
+      return;
+    }
+    const resolved = {
+      ...skill,
+      content: skill.source.content
+    };
+    register(resolved);
+    return () => {
+      unregister(skill.name);
+    };
+  }, [
+    skill.name,
+    skill.source.type === "inline" ? skill.source.content : "",
+    skill.strategy,
+    skill.description
+  ]);
+}
+function useSkillStatus() {
+  const { skills, registry } = useSkillContext();
+  const has = React2.useCallback(
+    (name) => registry.has(name),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [skills]
+  );
+  return {
+    skills,
+    count: skills.length,
+    has
+  };
+}
 
 // src/react/utils/permission-storage.ts
 var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
@@ -4583,6 +7264,34 @@ var ReactChat = class extends AbstractChat {
     return this.on("error", handler);
   }
   // ============================================
+  // Branching API — pass-throughs to ReactChatState
+  // ============================================
+  /**
+   * Navigate to a sibling branch (makes it the active path).
+   */
+  switchBranch(messageId) {
+    this.reactState.switchBranch(messageId);
+  }
+  /**
+   * Get branch navigation info for a message.
+   * Returns null if the message has no siblings.
+   */
+  getBranchInfo(messageId) {
+    return this.reactState.getBranchInfo(messageId);
+  }
+  /**
+   * Get all messages across all branches (for persistence).
+   */
+  getAllMessages() {
+    return this.reactState.getAllMessages();
+  }
+  /**
+   * Whether any message has siblings (branching has occurred).
+   */
+  get hasBranches() {
+    return this.reactState.hasBranches;
+  }
+  // ============================================
   // Override dispose to clean up state
   // ============================================
   dispose() {
@@ -4601,8 +7310,8 @@ function createReactChat(config) {
   return new ReactChat(config);
 }
 function useChat(config) {
-  const chatRef = react.useRef(null);
-  const [input, setInput] = react.useState("");
+  const chatRef = React2.useRef(null);
+  const [input, setInput] = React2.useState("");
   if (chatRef.current !== null && chatRef.current.disposed) {
     chatRef.current.revive();
   }
@@ -4624,51 +7333,74 @@ function useChat(config) {
       }
     });
   }
-  const messages = react.useSyncExternalStore(
+  const messages = React2.useSyncExternalStore(
     chatRef.current.subscribe,
     () => chatRef.current.messages,
     () => chatRef.current.messages
     // Server snapshot
   );
-  const status = react.useSyncExternalStore(
+  const status = React2.useSyncExternalStore(
     chatRef.current.subscribe,
     () => chatRef.current.status,
     () => "ready"
     // Server snapshot
   );
-  const error = react.useSyncExternalStore(
+  const error = React2.useSyncExternalStore(
     chatRef.current.subscribe,
     () => chatRef.current.error,
     () => void 0
     // Server snapshot
   );
+  const hasBranches = React2.useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.hasBranches,
+    () => false
+  );
   const isLoading = status === "streaming" || status === "submitted";
-  const sendMessage = react.useCallback(
+  const sendMessage = React2.useCallback(
     async (content, attachments) => {
       await chatRef.current?.sendMessage(content, attachments);
       setInput("");
     },
     []
   );
-  const stop = react.useCallback(() => {
+  const stop = React2.useCallback(() => {
     chatRef.current?.stop();
   }, []);
-  const clearMessages = react.useCallback(() => {
+  const clearMessages = React2.useCallback(() => {
     chatRef.current?.clearMessages();
   }, []);
-  const setMessages = react.useCallback((messages2) => {
+  const setMessages = React2.useCallback((messages2) => {
     chatRef.current?.setMessages(messages2);
   }, []);
-  const regenerate = react.useCallback(async (messageId) => {
+  const regenerate = React2.useCallback(async (messageId) => {
     await chatRef.current?.regenerate(messageId);
   }, []);
-  const continueWithToolResults = react.useCallback(
+  const continueWithToolResults = React2.useCallback(
     async (toolResults) => {
       await chatRef.current?.continueWithToolResults(toolResults);
     },
     []
   );
-  react.useEffect(() => {
+  const switchBranch = React2.useCallback((messageId) => {
+    chatRef.current?.switchBranch(messageId);
+  }, []);
+  const getBranchInfo = React2.useCallback(
+    (messageId) => {
+      return chatRef.current?.getBranchInfo(messageId) ?? null;
+    },
+    []
+  );
+  const editMessage = React2.useCallback(
+    async (messageId, newContent) => {
+      await chatRef.current?.sendMessage(newContent, void 0, {
+        editMessageId: messageId
+      });
+      setInput("");
+    },
+    []
+  );
+  React2.useEffect(() => {
     return () => {
       chatRef.current?.dispose();
     };
@@ -4686,17 +7418,30 @@ function useChat(config) {
     setMessages,
     regenerate,
     continueWithToolResults,
-    chatRef
+    chatRef,
+    // Branching
+    switchBranch,
+    getBranchInfo,
+    editMessage,
+    hasBranches
   };
 }
 
+// src/react/skill/define-skill.ts
+function defineSkill(def) {
+  return def;
+}
+
 exports.AbstractAgentLoop = AbstractAgentLoop;
 exports.AbstractChat = AbstractChat;
 exports.CopilotProvider = CopilotProvider;
+exports.MessageHistoryContext = MessageHistoryContext;
+exports.MessageTree = MessageTree;
 exports.ReactChat = ReactChat;
 exports.ReactChatState = ReactChatState;
 exports.ReactThreadManager = ReactThreadManager;
 exports.ReactThreadManagerState = ReactThreadManagerState;
+exports.SkillProvider = SkillProvider;
 exports.createMessageIntentHandler = createMessageIntentHandler;
 exports.createPermissionStorage = createPermissionStorage;
 exports.createReactChat = createReactChat;
@@ -4705,9 +7450,16 @@ exports.createReactThreadManager = createReactThreadManager;
 exports.createReactThreadManagerState = createReactThreadManagerState;
 exports.createSessionPermissionCache = createSessionPermissionCache;
 exports.createToolIntentHandler = createToolIntentHandler;
+exports.defaultMessageHistoryConfig = defaultMessageHistoryConfig;
+exports.defineSkill = defineSkill;
 exports.formatKnowledgeResultsForAI = formatKnowledgeResultsForAI;
 exports.initialAgentLoopState = initialAgentLoopState;
+exports.isCompactionMarker = isCompactionMarker;
+exports.keepToolPairsAtomic = keepToolPairsAtomic;
 exports.searchKnowledgeBase = searchKnowledgeBase;
+exports.toDisplayMessage = toDisplayMessage;
+exports.toLLMMessage = toLLMMessage;
+exports.toLLMMessages = toLLMMessages;
 exports.useAIAction = useAIAction;
 exports.useAIActions = useAIActions;
 exports.useAIContext = useAIContext;
@@ -4716,6 +7468,7 @@ exports.useAITools = useAITools;
 exports.useAgent = useAgent;
 exports.useCapabilities = useCapabilities;
 exports.useChat = useChat;
+exports.useContextStats = useContextStats;
 exports.useCopilot = useCopilot;
 exports.useDevLogger = useDevLogger;
 exports.useFeatureSupport = useFeatureSupport;
@@ -4723,6 +7476,10 @@ exports.useKnowledgeBase = useKnowledgeBase;
 exports.useMCPClient = useMCPClient;
 exports.useMCPTools = useMCPTools;
 exports.useMCPUIIntents = useMCPUIIntents;
+exports.useMessageHistory = useMessageHistory;
+exports.useMessageHistoryContext = useMessageHistoryContext;
+exports.useSkill = useSkill;
+exports.useSkillStatus = useSkillStatus;
 exports.useSuggestions = useSuggestions;
 exports.useSupportedMediaTypes = useSupportedMediaTypes;
 exports.useThreadManager = useThreadManager;
@@ -4731,5 +7488,5 @@ exports.useToolExecutor = useToolExecutor;
 exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
 exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-N6VZ7FOW.cjs.map
-//# sourceMappingURL=chunk-N6VZ7FOW.cjs.map
+//# sourceMappingURL=chunk-76RE7AJE.cjs.map
+//# sourceMappingURL=chunk-76RE7AJE.cjs.map