@protolabsai/proto 0.51.2 → 0.52.0

package/cli.js

@@ -168684,7 +168684,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.51.2";
+  const version2 = "0.52.0";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -168957,382 +168957,434 @@ var init_rateLimit = __esm({
   }
 });
 
-// node_modules/async-mutex/index.mjs
-function insertSorted(a2, v2) {
-  const i4 = findIndexFromEnd(a2, (other2) => v2.priority <= other2.priority);
-  a2.splice(i4 + 1, 0, v2);
-}
-function findIndexFromEnd(a2, predicate) {
-  for (let i4 = a2.length - 1; i4 >= 0; i4--) {
-    if (predicate(a2[i4])) {
-      return i4;
-    }
-  }
-  return -1;
+// packages/core/dist/src/utils/contextLengthError.js
+function parseInteger(value) {
+  return Number.parseInt(value.replace(/,/g, ""), 10);
 }
-var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2, Semaphore, __awaiter$1, Mutex;
-var init_async_mutex = __esm({
-  "node_modules/async-mutex/index.mjs"() {
-    init_esbuild_shims();
-    E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
-    E_ALREADY_LOCKED = new Error("mutex already locked");
-    E_CANCELED = new Error("request for lock canceled");
-    __awaiter$2 = function(thisArg, _arguments, P2, generator) {
-      function adopt(value) {
-        return value instanceof P2 ? value : new P2(function(resolve37) {
-          resolve37(value);
-        });
-      }
-      __name(adopt, "adopt");
-      return new (P2 || (P2 = Promise))(function(resolve37, reject) {
-        function fulfilled(value) {
-          try {
-            step(generator.next(value));
-          } catch (e4) {
-            reject(e4);
-          }
-        }
-        __name(fulfilled, "fulfilled");
-        function rejected(value) {
-          try {
-            step(generator["throw"](value));
-          } catch (e4) {
-            reject(e4);
-          }
-        }
-        __name(rejected, "rejected");
-        function step(result) {
-          result.done ? resolve37(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        __name(step, "step");
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-    };
-    Semaphore = class {
-      static {
-        __name(this, "Semaphore");
-      }
-      constructor(_value, _cancelError = E_CANCELED) {
-        this._value = _value;
-        this._cancelError = _cancelError;
-        this._queue = [];
-        this._weightedWaiters = [];
-      }
-      acquire(weight = 1, priority = 0) {
-        if (weight <= 0)
-          throw new Error(`invalid weight ${weight}: must be positive`);
-        return new Promise((resolve37, reject) => {
-          const task = { resolve: resolve37, reject, weight, priority };
-          const i4 = findIndexFromEnd(this._queue, (other2) => priority <= other2.priority);
-          if (i4 === -1 && weight <= this._value) {
-            this._dispatchItem(task);
-          } else {
-            this._queue.splice(i4 + 1, 0, task);
-          }
-        });
-      }
-      runExclusive(callback_1) {
-        return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
-          const [value, release2] = yield this.acquire(weight, priority);
-          try {
-            return yield callback(value);
-          } finally {
-            release2();
-          }
-        });
-      }
-      waitForUnlock(weight = 1, priority = 0) {
-        if (weight <= 0)
-          throw new Error(`invalid weight ${weight}: must be positive`);
-        if (this._couldLockImmediately(weight, priority)) {
-          return Promise.resolve();
-        } else {
-          return new Promise((resolve37) => {
-            if (!this._weightedWaiters[weight - 1])
-              this._weightedWaiters[weight - 1] = [];
-            insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve37, priority });
-          });
-        }
-      }
-      isLocked() {
-        return this._value <= 0;
-      }
-      getValue() {
-        return this._value;
-      }
-      setValue(value) {
-        this._value = value;
-        this._dispatchQueue();
-      }
-      release(weight = 1) {
-        if (weight <= 0)
-          throw new Error(`invalid weight ${weight}: must be positive`);
-        this._value += weight;
-        this._dispatchQueue();
-      }
-      cancel() {
-        this._queue.forEach((entry) => entry.reject(this._cancelError));
-        this._queue = [];
-      }
-      _dispatchQueue() {
-        this._drainUnlockWaiters();
-        while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
-          this._dispatchItem(this._queue.shift());
-          this._drainUnlockWaiters();
-        }
-      }
-      _dispatchItem(item) {
-        const previousValue = this._value;
-        this._value -= item.weight;
-        item.resolve([previousValue, this._newReleaser(item.weight)]);
-      }
-      _newReleaser(weight) {
-        let called = false;
-        return () => {
-          if (called)
-            return;
-          called = true;
-          this.release(weight);
-        };
-      }
-      _drainUnlockWaiters() {
-        if (this._queue.length === 0) {
-          for (let weight = this._value; weight > 0; weight--) {
-            const waiters = this._weightedWaiters[weight - 1];
-            if (!waiters)
-              continue;
-            waiters.forEach((waiter) => waiter.resolve());
-            this._weightedWaiters[weight - 1] = [];
-          }
-        } else {
-          const queuedPriority = this._queue[0].priority;
-          for (let weight = this._value; weight > 0; weight--) {
-            const waiters = this._weightedWaiters[weight - 1];
-            if (!waiters)
-              continue;
-            const i4 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
-            (i4 === -1 ? waiters : waiters.splice(0, i4)).forEach((waiter) => waiter.resolve());
-          }
-        }
-      }
-      _couldLockImmediately(weight, priority) {
-        return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
-      }
+function parseTokenCounts(text) {
+  const greaterThanMatch = text.match(/(\d[\d,]*)\s*tokens?\s*>\s*(\d[\d,]*)/i);
+  if (greaterThanMatch) {
+    return {
+      actualTokens: parseInteger(greaterThanMatch[1]),
+      limitTokens: parseInteger(greaterThanMatch[2])
     };
-    __name(insertSorted, "insertSorted");
-    __name(findIndexFromEnd, "findIndexFromEnd");
-    __awaiter$1 = function(thisArg, _arguments, P2, generator) {
-      function adopt(value) {
-        return value instanceof P2 ? value : new P2(function(resolve37) {
-          resolve37(value);
-        });
-      }
-      __name(adopt, "adopt");
-      return new (P2 || (P2 = Promise))(function(resolve37, reject) {
-        function fulfilled(value) {
-          try {
-            step(generator.next(value));
-          } catch (e4) {
-            reject(e4);
-          }
-        }
-        __name(fulfilled, "fulfilled");
-        function rejected(value) {
-          try {
-            step(generator["throw"](value));
-          } catch (e4) {
-            reject(e4);
-          }
-        }
-        __name(rejected, "rejected");
-        function step(result) {
-          result.done ? resolve37(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        __name(step, "step");
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
+  }
+  const openAiMatch = text.match(/maximum context length is\s*(\d[\d,]*)\s*tokens?[\s\S]*?(?:resulted in|requested|used)\s*(\d[\d,]*)\s*tokens?/i);
+  if (openAiMatch) {
+    return {
+      actualTokens: parseInteger(openAiMatch[2]),
+      limitTokens: parseInteger(openAiMatch[1])
     };
-    Mutex = class {
-      static {
-        __name(this, "Mutex");
-      }
-      constructor(cancelError) {
-        this._semaphore = new Semaphore(1, cancelError);
-      }
-      acquire() {
-        return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
-          const [, releaser] = yield this._semaphore.acquire(1, priority);
-          return releaser;
-        });
-      }
-      runExclusive(callback, priority = 0) {
-        return this._semaphore.runExclusive(() => callback(), 1, priority);
-      }
-      isLocked() {
-        return this._semaphore.isLocked();
-      }
-      waitForUnlock(priority = 0) {
-        return this._semaphore.waitForUnlock(1, priority);
-      }
-      release() {
-        if (this._semaphore.isLocked())
-          this._semaphore.release();
-      }
-      cancel() {
-        return this._semaphore.cancel();
-      }
+  }
+  const maxContextLimitMatch = text.match(/maximum context length is\s*(\d[\d,]*)\s*tokens?/i);
+  if (maxContextLimitMatch) {
+    return {
+      limitTokens: parseInteger(maxContextLimitMatch[1])
     };
   }
-});
-
-// packages/core/dist/src/utils/jsonl-utils.js
-import fs17 from "node:fs";
-import path16 from "node:path";
-import readline from "node:readline";
-function getFileLock(filePath) {
-  if (!fileLocks.has(filePath)) {
-    fileLocks.set(filePath, new Mutex());
+  const inputExceedsMatch = text.match(/input\s+token\s+(?:count|length)[^\d]*(\d[\d,]*)[\s\S]*?exceed(?:s|ed)?[\s\S]*?(?:maximum|limit)[^\d]*(\d[\d,]*)/i);
+  if (inputExceedsMatch) {
+    return {
+      actualTokens: parseInteger(inputExceedsMatch[1]),
+      limitTokens: parseInteger(inputExceedsMatch[2])
+    };
   }
-  return fileLocks.get(filePath);
+  return {};
 }
-async function readLines(filePath, count) {
-  try {
-    const fileStream = fs17.createReadStream(filePath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    const results = [];
-    for await (const line of rl) {
-      if (results.length >= count)
-        break;
-      const trimmed2 = line.trim();
-      if (trimmed2.length > 0) {
-        results.push(JSON.parse(trimmed2));
-      }
-    }
-    return results;
-  } catch (error40) {
-    if (error40.code !== "ENOENT") {
-      debugLogger21.error(`Error reading first ${count} lines from ${filePath}:`, error40);
+function tryParseEmbeddedJson(text) {
+  const trimmed2 = text.trim();
+  if (trimmed2.startsWith("{") || trimmed2.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed2);
+    } catch {
     }
-    return [];
   }
-}
-async function read(filePath) {
+  const start2 = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start2 === -1 || end <= start2) {
+    return void 0;
+  }
   try {
-    const fileStream = fs17.createReadStream(filePath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    const results = [];
-    for await (const line of rl) {
-      const trimmed2 = line.trim();
-      if (trimmed2.length > 0) {
-        results.push(JSON.parse(trimmed2));
-      }
-    }
-    return results;
-  } catch (error40) {
-    if (error40.code !== "ENOENT") {
-      debugLogger21.error(`Error reading ${filePath}:`, error40);
+    return JSON.parse(text.slice(start2, end + 1));
+  } catch {
+    return void 0;
+  }
+}
+function collectStrings(value, seen, depth = 0) {
+  if (depth > MAX_COLLECT_DEPTH || value === null || value === void 0) {
+    return [];
+  }
+  if (typeof value === "string") {
+    const parsed = tryParseEmbeddedJson(value);
+    if (parsed === void 0) {
+      return [value];
     }
+    return [value, ...collectStrings(parsed, seen, depth + 1)];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+  if (seen.has(value)) {
     return [];
   }
+  seen.add(value);
+  const strings = [];
+  if (value instanceof Error) {
+    strings.push(value.name, value.message);
+    strings.push(...collectStrings(value.cause, seen, depth + 1));
+  }
+  for (const [, nested] of Object.entries(value)) {
+    strings.push(...collectStrings(nested, seen, depth + 1));
+  }
+  return strings;
 }
-async function writeLine(filePath, data) {
-  const lock = getFileLock(filePath);
-  await lock.runExclusive(() => {
-    const line = `${JSON.stringify(data)}
-`;
-    const dir = path16.dirname(filePath);
-    if (!fs17.existsSync(dir)) {
-      fs17.mkdirSync(dir, { recursive: true });
+function uniqueNonEmpty(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const trimmed2 = value.trim();
+    if (!trimmed2 || seen.has(trimmed2)) {
+      continue;
     }
-    fs17.appendFileSync(filePath, line, "utf8");
-  });
+    seen.add(trimmed2);
+    result.push(trimmed2);
+  }
+  return result;
 }
-function writeLineSync(filePath, data) {
-  const line = `${JSON.stringify(data)}
-`;
-  const dir = path16.dirname(filePath);
-  if (!fs17.existsSync(dir)) {
-    fs17.mkdirSync(dir, { recursive: true });
+function getContextLengthExceededInfo(error40) {
+  const fragments = uniqueNonEmpty(collectStrings(error40, /* @__PURE__ */ new Set()));
+  const message = fragments.join("\n");
+  const isTimeout = TIMEOUT_PATTERNS.some((pattern) => pattern.test(message));
+  const isExceeded = !isTimeout && fragments.some((fragment) => CONTEXT_LENGTH_PATTERNS.some((pattern) => pattern.test(fragment)));
+  const counts = isExceeded ? parseTokenCounts(message) : {};
+  return {
+    isExceeded,
+    message,
+    ...counts
+  };
+}
+var MAX_COLLECT_DEPTH, TIMEOUT_PATTERNS, CONTEXT_LENGTH_PATTERNS;
+var init_contextLengthError = __esm({
+  "packages/core/dist/src/utils/contextLengthError.js"() {
+    "use strict";
+    init_esbuild_shims();
+    MAX_COLLECT_DEPTH = 4;
+    TIMEOUT_PATTERNS = [
+      /\bcontext deadline exceeded\b/i,
+      /\bdeadline exceeded\b/i,
+      /\b(?:request|connection|read|context)\s+timed out\b/i,
+      /\b(?:request|connection|read|context)\s+timeout\b/i,
+      /\b(?:timeout|timed out)\s+(?:after|while|during)\b/i
+    ];
+    CONTEXT_LENGTH_PATTERNS = [
+      /\bcontext[_\s-]?length[_\s-]?exceeded\b/i,
+      /\bmaximum context length\b/i,
+      /\bprompt\s+(?:is\s+)?too long\b/i,
+      /\binput\s+(?:token\s+)?(?:count\s+|length\s+)?(?:is\s+)?too long\b/i,
+      /\brange of input length should be\b/i,
+      /\btoo many tokens\b/i,
+      /\btokens?\s*>\s*[\d,]+\s*(?:maximum|max|limit)\b/i,
+      /\b(?:input|prompt|messages?|context)\b[^\n]{0,120}\btokens?\b[^\n]{0,120}\bexceed(?:s|ed|ing)?\b/i
+    ];
+    __name(parseInteger, "parseInteger");
+    __name(parseTokenCounts, "parseTokenCounts");
+    __name(tryParseEmbeddedJson, "tryParseEmbeddedJson");
+    __name(collectStrings, "collectStrings");
+    __name(uniqueNonEmpty, "uniqueNonEmpty");
+    __name(getContextLengthExceededInfo, "getContextLengthExceededInfo");
+  }
+});
+
+// packages/core/dist/src/utils/thoughtUtils.js
+function parseThought(rawText) {
+  const startIndex = rawText.indexOf(START_DELIMITER);
+  if (startIndex === -1) {
+    return { subject: "", description: rawText };
+  }
+  const endIndex = rawText.indexOf(END_DELIMITER, startIndex + START_DELIMITER.length);
+  if (endIndex === -1) {
+    return { subject: "", description: rawText };
   }
-  fs17.appendFileSync(filePath, line, "utf8");
+  const subject = rawText.substring(startIndex + START_DELIMITER.length, endIndex).trim();
+  const description = (rawText.substring(0, startIndex) + rawText.substring(endIndex + END_DELIMITER.length)).trim();
+  return { subject, description };
 }
-function write(filePath, data) {
-  const lines = data.map((item) => JSON.stringify(item)).join("\n");
-  const dir = path16.dirname(filePath);
-  if (!fs17.existsSync(dir)) {
-    fs17.mkdirSync(dir, { recursive: true });
+function getThoughtText(response) {
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+    if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
+      return candidate.content.parts.filter((part) => part.thought && !isInternalPart(part)).map((part) => part.text ?? "").join("");
+    }
   }
-  fs17.writeFileSync(filePath, `${lines}
-`, "utf8");
+  return null;
 }
-async function countLines(filePath) {
-  try {
-    const fileStream = fs17.createReadStream(filePath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
+var START_DELIMITER, END_DELIMITER;
+var init_thoughtUtils = __esm({
+  "packages/core/dist/src/utils/thoughtUtils.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_partUtils();
+    START_DELIMITER = "**";
+    END_DELIMITER = "**";
+    __name(parseThought, "parseThought");
+    __name(getThoughtText, "getThoughtText");
+  }
+});
+
+// packages/core/dist/src/utils/streamStall.js
+async function* withChunkTimeout(source2, timeoutMs) {
+  while (true) {
+    let timer;
+    const stallPromise = new Promise((_2, reject) => {
+      timer = setTimeout(() => reject(new StreamStallError(timeoutMs)), timeoutMs);
     });
-    let count = 0;
-    for await (const line of rl) {
-      if (line.trim().length > 0) {
-        count++;
+    let result;
+    try {
+      result = await Promise.race([source2.next(), stallPromise]);
+      clearTimeout(timer);
+    } catch (err3) {
+      clearTimeout(timer);
+      try {
+        void source2.return?.(void 0);
+      } catch {
       }
+      throw err3;
     }
-    return count;
-  } catch (error40) {
-    if (error40.code !== "ENOENT") {
-      debugLogger21.error(`Error counting lines in ${filePath}:`, error40);
-    }
-    return 0;
+    if (result.done)
+      return;
+    yield result.value;
   }
 }
-function exists(filePath) {
-  try {
-    const stats = fs17.statSync(filePath);
-    return stats.isFile() && stats.size > 0;
-  } catch {
-    return false;
+var StreamStallError;
+var init_streamStall = __esm({
+  "packages/core/dist/src/utils/streamStall.js"() {
+    "use strict";
+    init_esbuild_shims();
+    StreamStallError = class extends Error {
+      static {
+        __name(this, "StreamStallError");
+      }
+      timeoutMs;
+      constructor(timeoutMs) {
+        super(`Stream stalled: no data received for ${timeoutMs / 1e3}s. The model connection may have dropped \u2014 please try again.`);
+        this.name = "StreamStallError";
+        this.timeoutMs = timeoutMs;
+      }
+    };
+    __name(withChunkTimeout, "withChunkTimeout");
   }
+});
+
+// packages/core/dist/src/core/turn.js
+function getCitations(resp) {
+  return (resp.candidates?.[0]?.citationMetadata?.citations ?? []).filter((citation) => citation.uri !== void 0).map((citation) => {
+    if (citation.title) {
+      return `(${citation.title}) ${citation.uri}`;
+    }
+    return citation.uri;
+  });
 }
-var debugLogger21, fileLocks;
-var init_jsonl_utils = __esm({
-  "packages/core/dist/src/utils/jsonl-utils.js"() {
+var STREAM_STALL_TIMEOUT_MS, GeminiEventType, CompressionStatus, Turn;
+var init_turn = __esm({
+  "packages/core/dist/src/core/turn.js"() {
     "use strict";
     init_esbuild_shims();
-    init_async_mutex();
-    init_debugLogger();
-    debugLogger21 = createDebugLogger("JSONL");
-    fileLocks = /* @__PURE__ */ new Map();
-    __name(getFileLock, "getFileLock");
-    __name(readLines, "readLines");
-    __name(read, "read");
-    __name(writeLine, "writeLine");
-    __name(writeLineSync, "writeLineSync");
-    __name(write, "write");
-    __name(countLines, "countLines");
-    __name(exists, "exists");
+    init_node();
+    init_partUtils();
+    init_errorReporting();
+    init_errors();
+    init_thoughtUtils();
+    init_streamStall();
+    STREAM_STALL_TIMEOUT_MS = parseInt(process.env["PROTO_STREAM_STALL_TIMEOUT_MS"] ?? "300000", 10);
+    (function(GeminiEventType2) {
+      GeminiEventType2["Content"] = "content";
+      GeminiEventType2["ToolCallRequest"] = "tool_call_request";
+      GeminiEventType2["ToolCallResponse"] = "tool_call_response";
+      GeminiEventType2["ToolCallConfirmation"] = "tool_call_confirmation";
+      GeminiEventType2["UserCancelled"] = "user_cancelled";
+      GeminiEventType2["Error"] = "error";
+      GeminiEventType2["ChatCompressed"] = "chat_compressed";
+      GeminiEventType2["Thought"] = "thought";
+      GeminiEventType2["MaxSessionTurns"] = "max_session_turns";
+      GeminiEventType2["SessionTokenLimitExceeded"] = "session_token_limit_exceeded";
+      GeminiEventType2["Finished"] = "finished";
+      GeminiEventType2["LoopDetected"] = "loop_detected";
+      GeminiEventType2["Citation"] = "citation";
+      GeminiEventType2["Retry"] = "retry";
+      GeminiEventType2["HookSystemMessage"] = "hook_system_message";
+    })(GeminiEventType || (GeminiEventType = {}));
+    (function(CompressionStatus2) {
+      CompressionStatus2[CompressionStatus2["COMPRESSED"] = 1] = "COMPRESSED";
+      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_INFLATED_TOKEN_COUNT"] = 2] = "COMPRESSION_FAILED_INFLATED_TOKEN_COUNT";
+      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_TOKEN_COUNT_ERROR"] = 3] = "COMPRESSION_FAILED_TOKEN_COUNT_ERROR";
+      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_EMPTY_SUMMARY"] = 4] = "COMPRESSION_FAILED_EMPTY_SUMMARY";
+      CompressionStatus2[CompressionStatus2["NOOP"] = 5] = "NOOP";
+    })(CompressionStatus || (CompressionStatus = {}));
+    Turn = class {
+      static {
+        __name(this, "Turn");
+      }
+      chat;
+      prompt_id;
+      pendingToolCalls = [];
+      debugResponses = [];
+      pendingCitations = /* @__PURE__ */ new Set();
+      finishReason = void 0;
+      currentResponseId;
+      constructor(chat, prompt_id) {
+        this.chat = chat;
+        this.prompt_id = prompt_id;
+      }
+      // The run method yields simpler events suitable for server logic
+      async *run(model, req, signal) {
+        try {
+          const rawStream = await this.chat.sendMessageStream(model, {
+            message: req,
+            config: {
+              abortSignal: signal
+            }
+          }, this.prompt_id);
+          const responseStream = withChunkTimeout(rawStream, STREAM_STALL_TIMEOUT_MS);
+          for await (const streamEvent of responseStream) {
+            if (signal?.aborted) {
+              yield { type: GeminiEventType.UserCancelled };
+              return;
+            }
+            if (streamEvent.type === "retry") {
+              yield {
+                type: GeminiEventType.Retry,
+                retryInfo: streamEvent.retryInfo
+              };
+              continue;
+            }
+            const resp = streamEvent.value;
+            if (!resp)
+              continue;
+            this.debugResponses.push(resp);
+            if (resp.responseId) {
+              this.currentResponseId = resp.responseId;
+            }
+            const thoughtText = getThoughtText(resp);
+            if (thoughtText) {
+              yield {
+                type: GeminiEventType.Thought,
+                value: parseThought(thoughtText)
+              };
+            }
+            const text = getResponseText(resp);
+            if (text) {
+              yield { type: GeminiEventType.Content, value: text };
+            }
+            const functionCalls = resp.functionCalls ?? [];
+            for (const fnCall of functionCalls) {
+              const event = this.handlePendingFunctionCall(fnCall);
+              if (event) {
+                yield event;
+              }
+            }
+            for (const citation of getCitations(resp)) {
+              this.pendingCitations.add(citation);
+            }
+            const finishReason = resp.candidates?.[0]?.finishReason;
+            if (finishReason) {
+              if (finishReason === FinishReason.MAX_TOKENS) {
+                for (const tc of this.pendingToolCalls) {
+                  tc.wasOutputTruncated = true;
+                }
+              }
+              if (this.pendingCitations.size > 0) {
+                yield {
+                  type: GeminiEventType.Citation,
+                  value: `Citations:
+${[...this.pendingCitations].sort().join("\n")}`
+                };
+                this.pendingCitations.clear();
+              }
+              this.finishReason = finishReason;
+              yield {
+                type: GeminiEventType.Finished,
+                value: {
+                  reason: finishReason,
+                  usageMetadata: resp.usageMetadata
+                }
+              };
+            }
+          }
+        } catch (e4) {
+          if (signal.aborted) {
+            yield { type: GeminiEventType.UserCancelled };
+            return;
+          }
+          if (e4 instanceof StreamStallError) {
+            yield {
+              type: GeminiEventType.Error,
+              value: {
+                error: {
+                  message: e4.message,
+                  status: void 0
+                }
+              }
+            };
+            return;
+          }
+          const error40 = toFriendlyError(e4);
+          if (error40 instanceof UnauthorizedError) {
+            throw error40;
+          }
+          const contextForReport = [...this.chat.getHistory(
+            /*curated*/
+            true
+          ), req];
+          await reportError2(error40, "Error when talking to API", contextForReport, "Turn.run-sendMessageStream");
+          const status = typeof error40 === "object" && error40 !== null && "status" in error40 && typeof error40.status === "number" ? error40.status : void 0;
+          const structuredError = {
+            message: getErrorMessage(error40),
+            status
+          };
+          await this.chat.maybeIncludeSchemaDepthContext(structuredError);
+          yield { type: GeminiEventType.Error, value: { error: structuredError } };
+          return;
+        }
+      }
+      handlePendingFunctionCall(fnCall) {
+        const callId = fnCall.id ?? `${fnCall.name}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const name4 = fnCall.name || "undefined_tool_name";
+        const args2 = fnCall.args || {};
+        const toolCallRequest = {
+          callId,
+          name: name4,
+          args: args2,
+          isClientInitiated: false,
+          prompt_id: this.prompt_id,
+          response_id: this.currentResponseId
+        };
+        this.pendingToolCalls.push(toolCallRequest);
+        return { type: GeminiEventType.ToolCallRequest, value: toolCallRequest };
+      }
+      getDebugResponses() {
+        return this.debugResponses;
+      }
+    };
+    __name(getCitations, "getCitations");
   }
 });
 
 // packages/core/dist/src/utils/gitUtils.js
-import * as fs18 from "node:fs";
-import * as path17 from "node:path";
+import * as fs17 from "node:fs";
+import * as path16 from "node:path";
 import { execSync as execSync2 } from "node:child_process";
 function isGitRepository(directory) {
   try {
-    let currentDir = path17.resolve(directory);
+    let currentDir = path16.resolve(directory);
     while (true) {
-      const gitDir = path17.join(currentDir, ".git");
-      if (fs18.existsSync(gitDir)) {
+      const gitDir = path16.join(currentDir, ".git");
+      if (fs17.existsSync(gitDir)) {
         return true;
       }
-      const parentDir = path17.dirname(currentDir);
+      const parentDir = path16.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -169345,13 +169397,13 @@ function isGitRepository(directory) {
 }
 function findGitRoot(directory) {
   try {
-    let currentDir = path17.resolve(directory);
+    let currentDir = path16.resolve(directory);
     while (true) {
-      const gitDir = path17.join(currentDir, ".git");
-      if (fs18.existsSync(gitDir)) {
+      const gitDir = path16.join(currentDir, ".git");
+      if (fs17.existsSync(gitDir)) {
         return currentDir;
       }
-      const parentDir = path17.dirname(currentDir);
+      const parentDir = path16.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -169410,985 +169462,102 @@ var init_gitUtils = __esm({
       }
       const gitRoot = findGitRoot(cwd6);
       if (gitRoot) {
-        return path17.basename(gitRoot);
+        return path16.basename(gitRoot);
       }
       return void 0;
     }, "getGitRepoName");
   }
 });
 
-// packages/core/dist/src/services/chatRecordingService.js
-import path18 from "node:path";
-import fs19 from "node:fs";
-import { randomUUID as randomUUID2 } from "node:crypto";
-var debugLogger22, ChatRecordingService;
-var init_chatRecordingService = __esm({
-  "packages/core/dist/src/services/chatRecordingService.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_config3();
-    init_node();
-    init_jsonl_utils();
-    init_gitUtils();
-    init_debugLogger();
-    debugLogger22 = createDebugLogger("CHAT_RECORDING");
-    ChatRecordingService = class {
-      static {
-        __name(this, "ChatRecordingService");
-      }
-      /** UUID of the last written record in the chain */
-      lastRecordUuid = null;
-      config;
-      /** In-memory cache of the current session's custom title (for re-append on exit) */
-      currentCustomTitle;
-      constructor(config2) {
-        this.config = config2;
-        this.lastRecordUuid = config2.getResumedSessionData()?.lastCompletedUuid ?? null;
-        if (config2.getResumedSessionData()) {
-          try {
-            const sessionService = config2.getSessionService();
-            this.currentCustomTitle = sessionService.getSessionTitle(config2.getSessionId());
-            this.finalize();
-          } catch {
-          }
-        }
-      }
-      /**
-       * Returns the session ID.
-       * @returns The session ID.
-       */
-      getSessionId() {
-        return this.config.getSessionId();
-      }
-      /**
-       * Ensures the chats directory exists, creating it if it doesn't exist.
-       * @returns The path to the chats directory.
-       * @throws Error if the directory cannot be created.
-       */
-      ensureChatsDir() {
-        const projectDir = this.config.storage.getProjectDir();
-        const chatsDir = path18.join(projectDir, "chats");
-        try {
-          fs19.mkdirSync(chatsDir, { recursive: true });
-        } catch {
-        }
-        return chatsDir;
-      }
-      /**
-       * Ensures the conversation file exists, creating it if it doesn't exist.
-       * Uses atomic file creation to avoid race conditions.
-       * @returns The path to the conversation file.
-       * @throws Error if the file cannot be created or accessed.
-       */
-      ensureConversationFile() {
-        const chatsDir = this.ensureChatsDir();
-        const sessionId = this.getSessionId();
-        const safeFilename = `${sessionId}.jsonl`;
-        const conversationFile = path18.join(chatsDir, safeFilename);
-        if (fs19.existsSync(conversationFile)) {
-          return conversationFile;
-        }
-        try {
-          fs19.writeFileSync(conversationFile, "", { flag: "wx", encoding: "utf8" });
-        } catch (error40) {
-          const nodeError = error40;
-          if (nodeError.code !== "EEXIST") {
-            const message = error40 instanceof Error ? error40.message : String(error40);
-            throw new Error(`Failed to create conversation file at ${conversationFile}: ${message}`);
-          }
-        }
-        return conversationFile;
-      }
-      /**
-       * Creates base fields for a ChatRecord.
-       */
-      createBaseRecord(type) {
-        return {
-          uuid: randomUUID2(),
-          parentUuid: this.lastRecordUuid,
-          sessionId: this.getSessionId(),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type,
-          cwd: this.config.getProjectRoot(),
-          version: this.config.getCliVersion() || "unknown",
-          gitBranch: getGitBranch(this.config.getProjectRoot())
-        };
-      }
-      /**
-       * Appends a record to the session file and updates lastRecordUuid.
-       */
-      appendRecord(record2) {
-        try {
-          const conversationFile = this.ensureConversationFile();
-          writeLineSync(conversationFile, record2);
-          this.lastRecordUuid = record2.uuid;
-        } catch (error40) {
-          debugLogger22.error("Error appending record:", error40);
-          throw error40;
-        }
-      }
-      /**
-       * Records a user message.
-       * Writes immediately to disk.
-       *
-       * @param message The raw PartListUnion object as used with the API
-       */
-      recordUserMessage(message) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("user"),
-            message: createUserContent(message)
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving user message:", error40);
-        }
-      }
-      /**
-       * Records an assistant turn with all available data.
-       * Writes immediately to disk.
-       *
-       * @param data.message The raw PartListUnion object from the model response
-       * @param data.model The model name
-       * @param data.tokens Token usage statistics
-       * @param data.contextWindowSize Context window size of the model
-       * @param data.toolCallsMetadata Enriched tool call info for UI recovery
-       */
-      recordAssistantTurn(data) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("assistant"),
-            model: data.model
-          };
-          if (data.message !== void 0) {
-            record2.message = createModelContent(data.message);
-          }
-          if (data.tokens) {
-            record2.usageMetadata = data.tokens;
-          }
-          if (data.contextWindowSize !== void 0) {
-            record2.contextWindowSize = data.contextWindowSize;
-          }
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving assistant turn:", error40);
-        }
-      }
-      /**
-       * Records tool results (function responses) sent back to the model.
-       * Writes immediately to disk.
-       *
-       * @param message The raw PartListUnion object with functionResponse parts
-       * @param toolCallResult Optional tool call result info for UI recovery
-       */
-      recordToolResult(message, toolCallResult) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("tool_result"),
-            message: createUserContent(message)
-          };
-          if (toolCallResult) {
-            if (typeof toolCallResult.resultDisplay === "object" && toolCallResult.resultDisplay !== null && "type" in toolCallResult.resultDisplay && toolCallResult.resultDisplay.type === "task_execution") {
-              const taskResult = toolCallResult.resultDisplay;
-              record2.toolCallResult = {
-                ...toolCallResult,
-                resultDisplay: {
-                  ...taskResult,
-                  toolCalls: []
-                }
-              };
-            } else {
-              record2.toolCallResult = toolCallResult;
-            }
-          }
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving tool result:", error40);
-        }
-      }
-      /**
-       * Records a slash command invocation as a system record. This keeps the model
-       * history clean while allowing resume to replay UI output for commands like
-       * /about.
-       */
-      recordSlashCommand(payload) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "slash_command",
-            systemPayload: payload
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving slash command record:", error40);
-        }
-      }
-      /**
-       * Records a chat compression checkpoint as a system record. This keeps the UI
-       * history immutable while allowing resume/continue flows to reconstruct the
-       * compressed model-facing history from the stored snapshot.
-       */
-      recordChatCompression(payload) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "chat_compression",
-            systemPayload: payload
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving chat compression record:", error40);
-        }
-      }
-      /**
-       * Records a UI telemetry event for replaying metrics on resume.
-       */
-      recordUiTelemetryEvent(uiEvent) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "ui_telemetry",
-            systemPayload: { uiEvent }
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving ui telemetry record:", error40);
-        }
-      }
-      /**
-       * Records a custom title for the session (set via /rename).
-       * Appended as a system record so it persists with the session data.
-       * Also caches the title in memory for re-append on shutdown.
-       *
-       * @returns true if the record was written successfully, false on I/O error.
-       */
-      recordCustomTitle(customTitle) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "custom_title",
-            systemPayload: { customTitle }
-          };
-          this.appendRecord(record2);
-          this.currentCustomTitle = customTitle;
-          return true;
-        } catch (error40) {
-          debugLogger22.error("Error saving custom title record:", error40);
-          return false;
-        }
-      }
-      /**
-       * Finalizes the current session by re-appending cached metadata to EOF.
-       *
-       * Call this whenever leaving the current session — whether switching to
-       * another session, shutting down the process, or any other transition.
-       * This single entry point replaces scattered re-append calls and ensures
-       * the custom_title record stays within the last 64KB tail window that
-       * readSessionTitleFromFile() scans.
-       *
-       * Best-effort: errors are logged but never thrown.
-       */
-      finalize() {
-        if (!this.currentCustomTitle) {
-          return;
-        }
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "custom_title",
-            systemPayload: { customTitle: this.currentCustomTitle }
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error finalizing session metadata:", error40);
-        }
-      }
-      /**
-       * Records @-command metadata as a system record for UI reconstruction.
-       */
-      recordAtCommand(payload) {
-        try {
-          const record2 = {
-            ...this.createBaseRecord("system"),
-            type: "system",
-            subtype: "at_command",
-            systemPayload: payload
-          };
-          this.appendRecord(record2);
-        } catch (error40) {
-          debugLogger22.error("Error saving @-command record:", error40);
-        }
-      }
-    };
-  }
-});
-
-// packages/core/dist/src/core/geminiChat.js
-function isValidResponse2(response) {
-  if (response.usageMetadata) {
-    return true;
+// packages/core/dist/src/core/prompts.js
+import path17 from "node:path";
+import fs18 from "node:fs";
+import os6 from "node:os";
+import { execSync as execSync3 } from "node:child_process";
+import process3 from "node:process";
+function assemblePromptSections(sections) {
+  const stable = sections.filter((s5) => s5.volatility === "stable" && s5.content);
+  const workspace = sections.filter((s5) => s5.volatility === "workspace" && s5.content);
+  const run3 = sections.filter((s5) => s5.volatility === "run" && s5.content);
+  const stablePart = stable.map((s5) => s5.content).join("\n\n");
+  const nonStable = [...workspace, ...run3].map((s5) => s5.content).join("\n\n");
+  if (!stablePart)
+    return nonStable;
+  if (!nonStable)
+    return stablePart;
+  return `${stablePart}${CACHE_BOUNDARY_SENTINEL}${nonStable}`;
+}
+function resolvePathFromEnv(envVar) {
+  const trimmedEnvVar = envVar?.trim();
+  if (!trimmedEnvVar) {
+    return { isSwitch: false, value: null, isDisabled: false };
   }
-  if (response.candidates === void 0 || response.candidates.length === 0) {
-    return false;
+  const lowerEnvVar = trimmedEnvVar.toLowerCase();
+  if (["0", "false", "1", "true"].includes(lowerEnvVar)) {
+    const isDisabled = ["0", "false"].includes(lowerEnvVar);
+    return { isSwitch: true, value: lowerEnvVar, isDisabled };
   }
-  if (response.candidates.some((candidate) => candidate.finishReason)) {
-    return true;
+  let customPath = trimmedEnvVar;
+  if (customPath.startsWith("~/") || customPath === "~") {
+    try {
+      const home = os6.homedir();
+      if (customPath === "~") {
+        customPath = home;
+      } else {
+        customPath = path17.join(home, customPath.slice(2));
+      }
+    } catch (error40) {
+      debugLogger21.warn(`Could not resolve home directory for path: ${trimmedEnvVar}`, error40);
+      return { isSwitch: false, value: null, isDisabled: false };
+    }
   }
-  const content = response.candidates[0]?.content;
-  return content !== void 0 && isValidContent2(content);
-}
-function isValidNonThoughtTextPart(part) {
-  return typeof part.text === "string" && !part.thought && !part.thoughtSignature && // Technically, the model should never generate parts that have text and
-  //  any of these but we don't trust them so check anyways.
-  !part.functionCall && !part.functionResponse && !part.inlineData && !part.fileData;
+  return {
+    isSwitch: false,
+    value: path17.resolve(customPath),
+    isDisabled: false
+  };
 }
-function isValidContent2(content) {
-  if (content.parts === void 0 || content.parts.length === 0) {
-    return false;
-  }
-  for (const part of content.parts) {
-    if (part === void 0 || Object.keys(part).length === 0) {
-      return false;
-    }
-    if (!isValidContentPart(part)) {
-      return false;
-    }
+function getCustomSystemPrompt(customInstruction, userMemory, appendInstruction) {
+  let instructionText = "";
+  if (typeof customInstruction === "string") {
+    instructionText = customInstruction;
+  } else if (Array.isArray(customInstruction)) {
+    instructionText = customInstruction.map((part) => typeof part === "string" ? part : part.text || "").join("");
+  } else if (customInstruction && "parts" in customInstruction) {
+    instructionText = customInstruction.parts?.map((part) => typeof part === "string" ? part : part.text || "").join("") || "";
+  } else if (customInstruction && "text" in customInstruction) {
+    instructionText = customInstruction.text || "";
   }
-  return true;
+  const memorySuffix = buildSystemPromptSuffix(userMemory);
+  return `${instructionText}${memorySuffix}${buildSystemPromptSuffix(appendInstruction)}`;
 }
-function isValidContentPart(part) {
-  const isInvalid = !part.thought && !part.thoughtSignature && part.text !== void 0 && part.text === "" && part.functionCall === void 0;
-  return !isInvalid;
+function buildSystemPromptSuffix(text) {
+  const trimmed2 = text?.trim();
+  return trimmed2 ? `
+
+---
+
+${trimmed2}` : "";
 }
-function validateHistory2(history) {
-  for (const content of history) {
-    if (content.role !== "user" && content.role !== "model") {
-      throw new Error(`Role must be user or model, but got ${content.role}.`);
+function getCoreSystemPrompt(userMemory, model, appendInstruction, interactive = false) {
+  let systemMdEnabled = false;
+  let systemMdPath = path17.resolve(path17.join(QWEN_CONFIG_DIR, "system.md"));
+  const systemMdResolution = resolvePathFromEnv(process3.env["QWEN_SYSTEM_MD"]);
+  if (systemMdResolution.value && !systemMdResolution.isDisabled) {
+    systemMdEnabled = true;
+    if (!systemMdResolution.isSwitch) {
+      systemMdPath = systemMdResolution.value;
+    }
+    if (!fs18.existsSync(systemMdPath)) {
+      throw new Error(`missing system prompt file '${systemMdPath}'`);
     }
   }
-}
-function extractCuratedHistory2(comprehensiveHistory) {
-  if (comprehensiveHistory === void 0 || comprehensiveHistory.length === 0) {
-    return [];
-  }
-  const curatedHistory = [];
-  const length = comprehensiveHistory.length;
-  let i4 = 0;
-  while (i4 < length) {
-    if (comprehensiveHistory[i4].role === "user") {
-      curatedHistory.push(comprehensiveHistory[i4]);
-      i4++;
-    } else {
-      const modelOutput = [];
-      let isValid2 = true;
-      while (i4 < length && comprehensiveHistory[i4].role === "model") {
-        modelOutput.push(comprehensiveHistory[i4]);
-        if (isValid2 && !isValidContent2(comprehensiveHistory[i4])) {
-          isValid2 = false;
-        }
-        i4++;
-      }
-      if (isValid2) {
-        curatedHistory.push(...modelOutput);
-      }
-    }
-  }
-  return curatedHistory;
-}
-function hasTruncationCascade(contents) {
-  if (contents.length === 0)
-    return false;
-  const last2 = contents[contents.length - 1];
-  if (last2.role !== "user")
-    return false;
-  return last2.parts?.some((p2) => {
-    const err3 = p2.functionResponse?.response?.["error"];
-    return typeof err3 === "string" && err3.includes(TRUNCATION_CASCADE_MARKER);
-  }) ?? false;
-}
-function trimLargeToolResponsesFromContext(contents) {
-  return contents.map((content) => {
-    if (content.role !== "user" || !content.parts)
-      return content;
-    const needsTrim = content.parts.some((p2) => {
-      const out2 = p2.functionResponse?.response?.["output"];
-      return typeof out2 === "string" && out2.length > LARGE_TOOL_RESPONSE_TRIM_CHARS;
-    });
-    if (!needsTrim)
-      return content;
-    return {
-      ...content,
-      parts: content.parts.map((p2) => {
-        const out2 = p2.functionResponse?.response?.["output"];
-        if (typeof out2 !== "string" || out2.length <= LARGE_TOOL_RESPONSE_TRIM_CHARS)
-          return p2;
-        const trimmed2 = out2.slice(0, LARGE_TOOL_RESPONSE_TRIM_CHARS) + `
-
-[... output trimmed from ${out2.length} to ${LARGE_TOOL_RESPONSE_TRIM_CHARS} chars to reduce context size ...]`;
-        return {
-          ...p2,
-          functionResponse: {
-            ...p2.functionResponse,
-            response: {
-              ...p2.functionResponse.response,
-              output: trimmed2
-            }
-          }
-        };
-      })
-    };
-  });
-}
-function trimToolErrorsFromContext(contents, maxTrimPairs = 6) {
-  const trimmed2 = [...contents];
-  let trimmed_count = 0;
-  while (trimmed2.length >= 2 && trimmed_count < maxTrimPairs) {
-    const last2 = trimmed2[trimmed2.length - 1];
-    const prev = trimmed2[trimmed2.length - 2];
-    if (last2.role !== "user")
-      break;
-    const allErrors = last2.parts?.every((p2) => p2.functionResponse !== void 0 && typeof p2.functionResponse.response?.["error"] === "string");
-    if (!allErrors)
-      break;
-    if (prev.role !== "model")
-      break;
-    const hasToolCall2 = prev.parts?.some((p2) => p2.functionCall !== void 0);
-    if (!hasToolCall2)
-      break;
-    trimmed2.splice(trimmed2.length - 2, 2);
-    trimmed_count++;
-  }
-  return trimmed2;
-}
-function isSchemaDepthError(errorMessage) {
-  return errorMessage.includes("maximum schema depth exceeded");
-}
-function isInvalidArgumentError(errorMessage) {
-  return errorMessage.includes("Request contains an invalid argument");
-}
-var debugLogger23, StreamEventType, INVALID_CONTENT_RETRY_OPTIONS, INVALID_STREAM_RETRY_CONFIG, RATE_LIMIT_RETRY_OPTIONS, TRUNCATION_CASCADE_MARKER, LARGE_TOOL_RESPONSE_TRIM_CHARS, InvalidStreamError, GeminiChat;
-var init_geminiChat = __esm({
-  "packages/core/dist/src/core/geminiChat.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_node();
-    init_retry();
-    init_errors();
-    init_debugLogger();
-    init_errorParsing();
-    init_rateLimit();
-    init_tools();
-    init_loggers();
-    init_chatRecordingService();
-    init_types4();
-    debugLogger23 = createDebugLogger("QWEN_CODE_CHAT");
-    (function(StreamEventType2) {
-      StreamEventType2["CHUNK"] = "chunk";
-      StreamEventType2["RETRY"] = "retry";
-    })(StreamEventType || (StreamEventType = {}));
-    INVALID_CONTENT_RETRY_OPTIONS = {
-      maxAttempts: 2,
-      // 1 initial call + 1 retry
-      initialDelayMs: 500
-    };
-    INVALID_STREAM_RETRY_CONFIG = {
-      maxRetries: 2,
-      initialDelayMs: 2e3
-    };
-    RATE_LIMIT_RETRY_OPTIONS = {
-      maxRetries: 10,
-      delayMs: 6e4
-    };
-    __name(isValidResponse2, "isValidResponse");
-    __name(isValidNonThoughtTextPart, "isValidNonThoughtTextPart");
-    __name(isValidContent2, "isValidContent");
-    __name(isValidContentPart, "isValidContentPart");
-    __name(validateHistory2, "validateHistory");
-    __name(extractCuratedHistory2, "extractCuratedHistory");
-    TRUNCATION_CASCADE_MARKER = "truncated due to max_tokens limit";
-    LARGE_TOOL_RESPONSE_TRIM_CHARS = 1e4;
-    __name(hasTruncationCascade, "hasTruncationCascade");
-    __name(trimLargeToolResponsesFromContext, "trimLargeToolResponsesFromContext");
-    __name(trimToolErrorsFromContext, "trimToolErrorsFromContext");
-    InvalidStreamError = class extends Error {
-      static {
-        __name(this, "InvalidStreamError");
-      }
-      type;
-      constructor(message, type) {
-        super(message);
-        this.name = "InvalidStreamError";
-        this.type = type;
-      }
-    };
-    GeminiChat = class {
-      static {
-        __name(this, "GeminiChat");
-      }
-      config;
-      generationConfig;
-      history;
-      chatRecordingService;
-      telemetryService;
-      // A promise to represent the current state of the message being sent to the
-      // model.
-      sendPromise = Promise.resolve();
-      /**
-       * Creates a new GeminiChat instance.
-       *
-       * @param config - The configuration object.
-       * @param generationConfig - Optional generation configuration.
-       * @param history - Optional initial conversation history.
-       * @param chatRecordingService - Optional recording service. If provided, chat
-       *   messages will be recorded.
-       * @param telemetryService - Optional UI telemetry service. When provided,
-       *   prompt token counts are reported on each API response. Pass `undefined`
-       *   for sub-agent chats to avoid overwriting the main agent's context usage.
-       */
-      constructor(config2, generationConfig = {}, history = [], chatRecordingService, telemetryService) {
-        this.config = config2;
-        this.generationConfig = generationConfig;
-        this.history = history;
-        this.chatRecordingService = chatRecordingService;
-        this.telemetryService = telemetryService;
-        validateHistory2(history);
-      }
-      setSystemInstruction(sysInstr) {
-        this.generationConfig.systemInstruction = sysInstr;
-      }
-      /**
-       * Sends a message to the model and returns the response in chunks.
-       *
-       * @remarks
-       * This method will wait for the previous message to be processed before
-       * sending the next message.
-       *
-       * @see {@link Chat#sendMessage} for non-streaming method.
-       * @param params - parameters for sending the message.
-       * @return The model's response.
-       *
-       * @example
-       * ```ts
-       * const chat = ai.chats.create({model: 'gemini-2.0-flash'});
-       * const response = await chat.sendMessageStream({
-       * message: 'Why is the sky blue?'
-       * });
-       * for await (const chunk of response) {
-       * console.log(chunk.text);
-       * }
-       * ```
-       */
-      async sendMessageStream(model, params, prompt_id) {
-        await this.sendPromise;
-        let streamDoneResolver;
-        const streamDonePromise = new Promise((resolve37) => {
-          streamDoneResolver = resolve37;
-        });
-        this.sendPromise = streamDonePromise;
-        const userContent = createUserContent(params.message);
-        this.history.push(userContent);
-        let requestContents = this.getHistory(true);
-        if (hasTruncationCascade(requestContents)) {
-          const withoutErrors = trimToolErrorsFromContext(requestContents);
-          requestContents = trimLargeToolResponsesFromContext(withoutErrors);
-          debugLogger23.warn(`MAX_TOKENS cascade detected: trimmed context from ${this.getHistory(true).length} to ${requestContents.length} entries and capped large tool responses.`);
-        }
-        const self2 = this;
-        return async function* () {
-          try {
-            let lastError = new Error("Request failed after all retries.");
-            let rateLimitRetryCount = 0;
-            let invalidStreamRetryCount = 0;
-            const cgConfig = self2.config.getContentGeneratorConfig();
-            const maxRateLimitRetries = cgConfig?.maxRetries ?? RATE_LIMIT_RETRY_OPTIONS.maxRetries;
-            const extraRetryErrorCodes = cgConfig?.retryErrorCodes;
-            for (let attempt = 0; attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
-              try {
-                if (attempt > 0 || rateLimitRetryCount > 0 || invalidStreamRetryCount > 0) {
-                  yield { type: StreamEventType.RETRY };
-                }
-                const stream2 = await self2.makeApiCallAndProcessStream(model, requestContents, params, prompt_id);
-                for await (const chunk of stream2) {
-                  yield { type: StreamEventType.CHUNK, value: chunk };
-                }
-                lastError = null;
-                break;
-              } catch (error40) {
-                lastError = error40;
-                const isRateLimit = isRateLimitError(error40, extraRetryErrorCodes);
-                if (isRateLimit && rateLimitRetryCount < maxRateLimitRetries) {
-                  rateLimitRetryCount++;
-                  const delayMs = RATE_LIMIT_RETRY_OPTIONS.delayMs;
-                  const message = parseAndFormatApiError(error40 instanceof Error ? error40.message : String(error40));
-                  debugLogger23.warn(`Rate limit throttling detected (retry ${rateLimitRetryCount}/${maxRateLimitRetries}). Waiting ${delayMs / 1e3}s before retrying...`);
-                  yield {
-                    type: StreamEventType.RETRY,
-                    retryInfo: {
-                      message,
-                      attempt: rateLimitRetryCount,
-                      maxRetries: maxRateLimitRetries,
-                      delayMs
-                    }
-                  };
-                  attempt--;
-                  await new Promise((res) => setTimeout(res, delayMs));
-                  continue;
-                }
-                const isTransientStreamError = error40 instanceof InvalidStreamError;
-                if (isTransientStreamError && invalidStreamRetryCount < INVALID_STREAM_RETRY_CONFIG.maxRetries) {
-                  invalidStreamRetryCount++;
-                  const delayMs = INVALID_STREAM_RETRY_CONFIG.initialDelayMs * invalidStreamRetryCount;
-                  debugLogger23.warn(`Invalid stream [${error40.type}] (retry ${invalidStreamRetryCount}/${INVALID_STREAM_RETRY_CONFIG.maxRetries}). Waiting ${delayMs / 1e3}s before retrying...`);
-                  logContentRetry(self2.config, new ContentRetryEvent(invalidStreamRetryCount - 1, error40.type, delayMs, model));
-                  yield { type: StreamEventType.RETRY };
-                  attempt--;
-                  await new Promise((res) => setTimeout(res, delayMs));
-                  continue;
-                }
-                if (isTransientStreamError && error40.type === "NO_RESPONSE_TEXT") {
-                  const trimmedContents = trimToolErrorsFromContext(requestContents);
-                  if (trimmedContents.length < requestContents.length) {
-                    debugLogger23.warn(`NO_RESPONSE_TEXT: retrying with trimmed context (removed ${requestContents.length - trimmedContents.length} tool-error messages)`);
-                    try {
-                      const stream2 = await self2.makeApiCallAndProcessStream(model, trimmedContents, params, prompt_id);
-                      for await (const chunk of stream2) {
-                        yield { type: StreamEventType.CHUNK, value: chunk };
-                      }
-                      lastError = null;
-                    } catch {
-                    }
-                  }
-                  break;
-                }
-                if (isTransientStreamError) {
-                  break;
-                }
-                const isContentError = error40 instanceof InvalidStreamError;
-                if (isContentError) {
-                  if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
-                    logContentRetry(self2.config, new ContentRetryEvent(attempt, error40.type, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs, model));
-                    await new Promise((res) => setTimeout(res, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs * (attempt + 1)));
-                    continue;
-                  }
-                }
-                break;
-              }
-            }
-            if (lastError) {
-              if (lastError instanceof InvalidStreamError) {
-                const totalAttempts = invalidStreamRetryCount + 1;
-                logContentRetryFailure(self2.config, new ContentRetryFailureEvent(totalAttempts, lastError.type, model));
-              }
-              throw lastError;
-            }
-          } finally {
-            streamDoneResolver();
-          }
-        }();
-      }
-      async makeApiCallAndProcessStream(model, requestContents, params, prompt_id) {
-        const apiCall = /* @__PURE__ */ __name(() => this.config.getContentGenerator().generateContentStream({
-          model,
-          contents: requestContents,
-          config: { ...this.generationConfig, ...params.config }
-        }, prompt_id), "apiCall");
-        const streamResponse2 = await retryWithBackoff(apiCall, {
-          shouldRetryOnError: /* @__PURE__ */ __name((error40) => {
-            if (error40 instanceof Error) {
-              if (isSchemaDepthError(error40.message))
-                return false;
-              if (isInvalidArgumentError(error40.message))
-                return false;
-            }
-            const status = getErrorStatus(error40);
-            if (status === 400)
-              return false;
-            if (status === 429)
-              return true;
-            if (status && status >= 500 && status < 600)
-              return true;
-            return false;
-          }, "shouldRetryOnError")
-        });
-        return this.processStreamResponse(model, streamResponse2);
-      }
-      /**
-       * Returns the chat history.
-       *
-       * @remarks
-       * The history is a list of contents alternating between user and model.
-       *
-       * There are two types of history:
-       * - The `curated history` contains only the valid turns between user and
-       * model, which will be included in the subsequent requests sent to the model.
-       * - The `comprehensive history` contains all turns, including invalid or
-       * empty model outputs, providing a complete record of the history.
-       *
-       * The history is updated after receiving the response from the model,
-       * for streaming response, it means receiving the last chunk of the response.
-       *
-       * The `comprehensive history` is returned by default. To get the `curated
-       * history`, set the `curated` parameter to `true`.
-       *
-       * @param curated - whether to return the curated history or the comprehensive
-       * history.
-       * @return History contents alternating between user and model for the entire
-       * chat session.
-       */
-      getHistory(curated = false) {
-        const history = curated ? extractCuratedHistory2(this.history) : this.history;
-        return structuredClone(history);
-      }
-      /**
-       * Clears the chat history.
-       */
-      clearHistory() {
-        this.history = [];
-      }
-      /**
-       * Adds a new entry to the chat history.
-       */
-      addHistory(content) {
-        this.history.push(content);
-      }
-      setHistory(history) {
-        this.history = history;
-      }
-      stripThoughtsFromHistory() {
-        this.history = this.history.map((content) => {
-          if (!content.parts)
-            return content;
-          const filteredParts = content.parts.filter((part) => !(part && typeof part === "object" && "thought" in part && part.thought)).map((part) => {
-            if (part && typeof part === "object" && "thoughtSignature" in part) {
-              const newPart = { ...part };
-              delete newPart.thoughtSignature;
-              return newPart;
-            }
-            return part;
-          });
-          return {
-            ...content,
-            parts: filteredParts
-          };
-        }).filter((content) => content.parts && content.parts.length > 0);
-      }
-      /**
-       * Pop all orphaned trailing user entries from chat history.
-       * In a valid conversation the last entry is always a model response;
-       * any trailing user entries are leftovers from a request that failed.
-       */
-      stripOrphanedUserEntriesFromHistory() {
-        while (this.history.length > 0 && this.history[this.history.length - 1].role === "user") {
-          this.history.pop();
-        }
-      }
-      setTools(tools) {
-        this.generationConfig.tools = tools;
-      }
-      /** Returns a shallow copy of the current generation config (for cache param snapshots). */
-      getGenerationConfig() {
-        return { ...this.generationConfig };
-      }
-      async maybeIncludeSchemaDepthContext(error40) {
-        if (isSchemaDepthError(error40.message) || isInvalidArgumentError(error40.message)) {
-          const tools = this.config.getToolRegistry().getAllTools();
-          const cyclicSchemaTools = [];
-          for (const tool of tools) {
-            if (tool.schema.parametersJsonSchema && hasCycleInSchema(tool.schema.parametersJsonSchema) || tool.schema.parameters && hasCycleInSchema(tool.schema.parameters)) {
-              cyclicSchemaTools.push(tool.displayName);
-            }
-          }
-          if (cyclicSchemaTools.length > 0) {
-            const extraDetails = `
-
-This error was probably caused by cyclic schema references in one of the following tools, try disabling them with excludeTools:
-
- - ` + cyclicSchemaTools.join(`
- - `) + `
-`;
-            error40.message += extraDetails;
-          }
-        }
-      }
-      async *processStreamResponse(model, streamResponse2) {
-        const allModelParts = [];
-        let usageMetadata;
-        let hasToolCall2 = false;
-        let hasFinishReason = false;
-        for await (const chunk of streamResponse2) {
-          hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
-          if (isValidResponse2(chunk)) {
-            const content = chunk.candidates?.[0]?.content;
-            if (content?.parts) {
-              if (content.parts.some((part) => part.functionCall)) {
-                hasToolCall2 = true;
-              }
-              allModelParts.push(...content.parts);
-            }
-          }
-          if (chunk.usageMetadata) {
-            usageMetadata = chunk.usageMetadata;
-            const lastPromptTokenCount = usageMetadata.totalTokenCount || usageMetadata.promptTokenCount;
-            if (lastPromptTokenCount && this.telemetryService) {
-              this.telemetryService.setLastPromptTokenCount(lastPromptTokenCount);
-            }
-            if (usageMetadata.cachedContentTokenCount && this.telemetryService) {
-              this.telemetryService.setLastCachedContentTokenCount(usageMetadata.cachedContentTokenCount);
-            }
-          }
-          yield chunk;
-        }
-        let thoughtContentPart;
-        const thoughtText = allModelParts.filter((part) => part.thought).map((part) => part.text).join("").trim();
-        if (thoughtText !== "") {
-          thoughtContentPart = {
-            text: thoughtText,
-            thought: true
-          };
-          const thoughtSignature = allModelParts.filter((part) => part.thoughtSignature && part.thought)?.[0]?.thoughtSignature;
-          if (thoughtContentPart && thoughtSignature) {
-            thoughtContentPart.thoughtSignature = thoughtSignature;
-          }
-        }
-        const contentParts = allModelParts.filter((part) => !part.thought);
-        const consolidatedHistoryParts = [];
-        for (const part of contentParts) {
-          const lastPart = consolidatedHistoryParts[consolidatedHistoryParts.length - 1];
-          if (lastPart?.text && isValidNonThoughtTextPart(lastPart) && isValidNonThoughtTextPart(part)) {
-            lastPart.text += part.text;
-          } else if (isValidContentPart(part)) {
-            consolidatedHistoryParts.push(part);
-          }
-        }
-        const contentText = consolidatedHistoryParts.filter((part) => part.text).map((part) => part.text).join("").trim();
-        if (thoughtContentPart || contentText || hasToolCall2 || usageMetadata) {
-          const contextWindowSize = this.config.getContentGeneratorConfig()?.contextWindowSize;
-          this.chatRecordingService?.recordAssistantTurn({
-            model,
-            message: [
-              ...thoughtContentPart ? [thoughtContentPart] : [],
-              ...contentText ? [{ text: contentText }] : [],
-              ...hasToolCall2 ? contentParts.filter((part) => part.functionCall).map((part) => ({ functionCall: part.functionCall })) : []
-            ],
-            tokens: usageMetadata,
-            contextWindowSize
-          });
-        }
-        if (!hasToolCall2 && (!hasFinishReason || !contentText)) {
-          if (!hasFinishReason) {
-            throw new InvalidStreamError("Model stream ended without a finish reason.", "NO_FINISH_REASON");
-          } else {
-            throw new InvalidStreamError("Model stream ended with empty response text.", "NO_RESPONSE_TEXT");
-          }
-        }
-        this.history.push({
-          role: "model",
-          parts: [
-            ...thoughtContentPart ? [thoughtContentPart] : [],
-            ...consolidatedHistoryParts
-          ]
-        });
-      }
-    };
-    __name(isSchemaDepthError, "isSchemaDepthError");
-    __name(isInvalidArgumentError, "isInvalidArgumentError");
-  }
-});
-
-// packages/core/dist/src/core/prompts.js
-import path19 from "node:path";
-import fs20 from "node:fs";
-import os6 from "node:os";
-import { execSync as execSync3 } from "node:child_process";
-import process3 from "node:process";
-function assemblePromptSections(sections) {
-  const stable = sections.filter((s5) => s5.volatility === "stable" && s5.content);
-  const workspace = sections.filter((s5) => s5.volatility === "workspace" && s5.content);
-  const run3 = sections.filter((s5) => s5.volatility === "run" && s5.content);
-  const stablePart = stable.map((s5) => s5.content).join("\n\n");
-  const nonStable = [...workspace, ...run3].map((s5) => s5.content).join("\n\n");
-  if (!stablePart)
-    return nonStable;
-  if (!nonStable)
-    return stablePart;
-  return `${stablePart}${CACHE_BOUNDARY_SENTINEL}${nonStable}`;
-}
-function resolvePathFromEnv(envVar) {
-  const trimmedEnvVar = envVar?.trim();
-  if (!trimmedEnvVar) {
-    return { isSwitch: false, value: null, isDisabled: false };
-  }
-  const lowerEnvVar = trimmedEnvVar.toLowerCase();
-  if (["0", "false", "1", "true"].includes(lowerEnvVar)) {
-    const isDisabled = ["0", "false"].includes(lowerEnvVar);
-    return { isSwitch: true, value: lowerEnvVar, isDisabled };
-  }
-  let customPath = trimmedEnvVar;
-  if (customPath.startsWith("~/") || customPath === "~") {
-    try {
-      const home = os6.homedir();
-      if (customPath === "~") {
-        customPath = home;
-      } else {
-        customPath = path19.join(home, customPath.slice(2));
-      }
-    } catch (error40) {
-      debugLogger24.warn(`Could not resolve home directory for path: ${trimmedEnvVar}`, error40);
-      return { isSwitch: false, value: null, isDisabled: false };
-    }
-  }
-  return {
-    isSwitch: false,
-    value: path19.resolve(customPath),
-    isDisabled: false
-  };
-}
-function getCustomSystemPrompt(customInstruction, userMemory, appendInstruction) {
-  let instructionText = "";
-  if (typeof customInstruction === "string") {
-    instructionText = customInstruction;
-  } else if (Array.isArray(customInstruction)) {
-    instructionText = customInstruction.map((part) => typeof part === "string" ? part : part.text || "").join("");
-  } else if (customInstruction && "parts" in customInstruction) {
-    instructionText = customInstruction.parts?.map((part) => typeof part === "string" ? part : part.text || "").join("") || "";
-  } else if (customInstruction && "text" in customInstruction) {
-    instructionText = customInstruction.text || "";
-  }
-  const memorySuffix = buildSystemPromptSuffix(userMemory);
-  return `${instructionText}${memorySuffix}${buildSystemPromptSuffix(appendInstruction)}`;
-}
-function buildSystemPromptSuffix(text) {
-  const trimmed2 = text?.trim();
-  return trimmed2 ? `
-
----
-
-${trimmed2}` : "";
-}
-function getCoreSystemPrompt(userMemory, model, appendInstruction, interactive = false) {
-  let systemMdEnabled = false;
-  let systemMdPath = path19.resolve(path19.join(QWEN_CONFIG_DIR, "system.md"));
-  const systemMdResolution = resolvePathFromEnv(process3.env["QWEN_SYSTEM_MD"]);
-  if (systemMdResolution.value && !systemMdResolution.isDisabled) {
-    systemMdEnabled = true;
-    if (!systemMdResolution.isSwitch) {
-      systemMdPath = systemMdResolution.value;
-    }
-    if (!fs20.existsSync(systemMdPath)) {
-      throw new Error(`missing system prompt file '${systemMdPath}'`);
-    }
-  }
-  if (systemMdEnabled) {
-    const customPrompt = fs20.readFileSync(systemMdPath, "utf8");
-    const memorySuffix2 = buildSystemPromptSuffix(userMemory);
-    const appendSuffix2 = buildSystemPromptSuffix(appendInstruction);
-    const full2 = `${customPrompt}${memorySuffix2}${appendSuffix2}`;
-    return { staticPrefix: full2, dynamicSuffix: "", full: full2 };
+  if (systemMdEnabled) {
+    const customPrompt = fs18.readFileSync(systemMdPath, "utf8");
+    const memorySuffix2 = buildSystemPromptSuffix(userMemory);
+    const appendSuffix2 = buildSystemPromptSuffix(appendInstruction);
+    const full2 = `${customPrompt}${memorySuffix2}${appendSuffix2}`;
+    return { staticPrefix: full2, dynamicSuffix: "", full: full2 };
   }
   const staticPrefix = `
 You are proto, an interactive CLI agent built by protoLabs.studio, specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
@@ -170637,7 +169806,7 @@ Workspace: ${parts2} files
 ${function() {
     if (!interactive)
       return "";
-    if (!fs20.existsSync(path19.join(process3.cwd(), ".beads")))
+    if (!fs18.existsSync(path17.join(process3.cwd(), ".beads")))
       return "";
     return `
 # Beads (cross-session task tracker)
@@ -170673,8 +169842,8 @@ Your core function is efficient and safe assistance. Balance extreme conciseness
   const writeSystemMdResolution = resolvePathFromEnv(process3.env["QWEN_WRITE_SYSTEM_MD"]);
   if (writeSystemMdResolution.value && !writeSystemMdResolution.isDisabled) {
     const writePath = writeSystemMdResolution.isSwitch ? systemMdPath : writeSystemMdResolution.value;
-    fs20.mkdirSync(path19.dirname(writePath), { recursive: true });
-    fs20.writeFileSync(writePath, basePrompt);
+    fs18.mkdirSync(path17.dirname(writePath), { recursive: true });
+    fs18.writeFileSync(writePath, basePrompt);
   }
   const memorySuffix = userMemory && userMemory.trim().length > 0 ? buildSystemPromptSuffix(userMemory) : "";
   const appendSuffix = buildSystemPromptSuffix(appendInstruction);
@@ -170781,7 +169950,7 @@ function getToolCallExamples(model) {
       case "general":
         return generalToolCallExamples;
       default:
-        debugLogger24.warn(`Unknown QWEN_CODE_TOOL_CALL_STYLE value: ${toolCallStyle}. Using model-based detection.`);
+        debugLogger21.warn(`Unknown QWEN_CODE_TOOL_CALL_STYLE value: ${toolCallStyle}. Using model-based detection.`);
         break;
     }
   }
@@ -170834,7 +170003,7 @@ function buildCapabilityManifest(mcpToolsByServer, activeSkills) {
 
 ${sections.join("\n\n")}`;
 }
-var debugLogger24, CACHE_BOUNDARY_SENTINEL, generalToolCallExamples, qwenCoderToolCallExamples, qwenVlToolCallExamples, INSIGHT_PROMPTS;
+var debugLogger21, CACHE_BOUNDARY_SENTINEL, generalToolCallExamples, qwenCoderToolCallExamples, qwenVlToolCallExamples, INSIGHT_PROMPTS;
 var init_prompts = __esm({
   "packages/core/dist/src/core/prompts.js"() {
     "use strict";
@@ -170843,7 +170012,7 @@ var init_prompts = __esm({
     init_gitUtils();
     init_memoryTool();
     init_debugLogger();
-    debugLogger24 = createDebugLogger("PROMPTS");
+    debugLogger21 = createDebugLogger("PROMPTS");
     CACHE_BOUNDARY_SENTINEL = "\n__CACHE_BOUNDARY__\n";
     __name(assemblePromptSections, "assemblePromptSections");
     __name(resolvePathFromEnv, "resolvePathFromEnv");
@@ -171362,320 +170531,6 @@ Call respond_in_schema function with A VALID JSON OBJECT as argument:
   }
 });
 
-// packages/core/dist/src/backgroundShells/notifications.js
-function escapeXml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildBackgroundTaskNotification(task) {
-  const exitLine = task.exitCode !== void 0 && task.exitCode !== null ? `
-<exit_code>${task.exitCode}</exit_code>` : "";
-  const summary = (() => {
-    const desc2 = task.description || task.command;
-    switch (task.status) {
-      case "completed":
-        return `Background command "${desc2}" completed${task.exitCode != null ? ` (exit code ${task.exitCode})` : ""}.`;
-      case "failed":
-        return `Background command "${desc2}" failed${task.exitCode != null ? ` with exit code ${task.exitCode}` : ""}.`;
-      case "killed":
-        return `Background command "${desc2}" was stopped.`;
-      default:
-        return `Background command "${desc2}" ended in unknown state.`;
-    }
-  })();
-  return [
-    "<task_notification>",
-    `<task_id>${task.id}</task_id>`,
-    `<output_file>${task.outputPath}</output_file>`,
-    `<status>${task.status}</status>${exitLine}`,
-    `<summary>${escapeXml(summary)}</summary>`,
-    "</task_notification>",
-    "",
-    `Read ${task.outputPath} to see the full output.`
-  ].join("\n");
-}
-var init_notifications = __esm({
-  "packages/core/dist/src/backgroundShells/notifications.js"() {
-    "use strict";
-    init_esbuild_shims();
-    __name(escapeXml, "escapeXml");
-    __name(buildBackgroundTaskNotification, "buildBackgroundTaskNotification");
-  }
-});
-
-// packages/core/dist/src/utils/thoughtUtils.js
-function parseThought(rawText) {
-  const startIndex = rawText.indexOf(START_DELIMITER);
-  if (startIndex === -1) {
-    return { subject: "", description: rawText };
-  }
-  const endIndex = rawText.indexOf(END_DELIMITER, startIndex + START_DELIMITER.length);
-  if (endIndex === -1) {
-    return { subject: "", description: rawText };
-  }
-  const subject = rawText.substring(startIndex + START_DELIMITER.length, endIndex).trim();
-  const description = (rawText.substring(0, startIndex) + rawText.substring(endIndex + END_DELIMITER.length)).trim();
-  return { subject, description };
-}
-function getThoughtText(response) {
-  if (response.candidates && response.candidates.length > 0) {
-    const candidate = response.candidates[0];
-    if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
-      return candidate.content.parts.filter((part) => part.thought && !isInternalPart(part)).map((part) => part.text ?? "").join("");
-    }
-  }
-  return null;
-}
-var START_DELIMITER, END_DELIMITER;
-var init_thoughtUtils = __esm({
-  "packages/core/dist/src/utils/thoughtUtils.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_partUtils();
-    START_DELIMITER = "**";
-    END_DELIMITER = "**";
-    __name(parseThought, "parseThought");
-    __name(getThoughtText, "getThoughtText");
-  }
-});
-
-// packages/core/dist/src/utils/streamStall.js
-async function* withChunkTimeout(source2, timeoutMs) {
-  while (true) {
-    let timer;
-    const stallPromise = new Promise((_2, reject) => {
-      timer = setTimeout(() => reject(new StreamStallError(timeoutMs)), timeoutMs);
-    });
-    let result;
-    try {
-      result = await Promise.race([source2.next(), stallPromise]);
-      clearTimeout(timer);
-    } catch (err3) {
-      clearTimeout(timer);
-      try {
-        void source2.return?.(void 0);
-      } catch {
-      }
-      throw err3;
-    }
-    if (result.done)
-      return;
-    yield result.value;
-  }
-}
-var StreamStallError;
-var init_streamStall = __esm({
-  "packages/core/dist/src/utils/streamStall.js"() {
-    "use strict";
-    init_esbuild_shims();
-    StreamStallError = class extends Error {
-      static {
-        __name(this, "StreamStallError");
-      }
-      timeoutMs;
-      constructor(timeoutMs) {
-        super(`Stream stalled: no data received for ${timeoutMs / 1e3}s. The model connection may have dropped \u2014 please try again.`);
-        this.name = "StreamStallError";
-        this.timeoutMs = timeoutMs;
-      }
-    };
-    __name(withChunkTimeout, "withChunkTimeout");
-  }
-});
-
-// packages/core/dist/src/core/turn.js
-function getCitations(resp) {
-  return (resp.candidates?.[0]?.citationMetadata?.citations ?? []).filter((citation) => citation.uri !== void 0).map((citation) => {
-    if (citation.title) {
-      return `(${citation.title}) ${citation.uri}`;
-    }
-    return citation.uri;
-  });
-}
-var STREAM_STALL_TIMEOUT_MS, GeminiEventType, CompressionStatus, Turn;
-var init_turn = __esm({
-  "packages/core/dist/src/core/turn.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_node();
-    init_partUtils();
-    init_errorReporting();
-    init_errors();
-    init_thoughtUtils();
-    init_streamStall();
-    STREAM_STALL_TIMEOUT_MS = parseInt(process.env["PROTO_STREAM_STALL_TIMEOUT_MS"] ?? "300000", 10);
-    (function(GeminiEventType2) {
-      GeminiEventType2["Content"] = "content";
-      GeminiEventType2["ToolCallRequest"] = "tool_call_request";
-      GeminiEventType2["ToolCallResponse"] = "tool_call_response";
-      GeminiEventType2["ToolCallConfirmation"] = "tool_call_confirmation";
-      GeminiEventType2["UserCancelled"] = "user_cancelled";
-      GeminiEventType2["Error"] = "error";
-      GeminiEventType2["ChatCompressed"] = "chat_compressed";
-      GeminiEventType2["Thought"] = "thought";
-      GeminiEventType2["MaxSessionTurns"] = "max_session_turns";
-      GeminiEventType2["SessionTokenLimitExceeded"] = "session_token_limit_exceeded";
-      GeminiEventType2["Finished"] = "finished";
-      GeminiEventType2["LoopDetected"] = "loop_detected";
-      GeminiEventType2["Citation"] = "citation";
-      GeminiEventType2["Retry"] = "retry";
-      GeminiEventType2["HookSystemMessage"] = "hook_system_message";
-    })(GeminiEventType || (GeminiEventType = {}));
-    (function(CompressionStatus2) {
-      CompressionStatus2[CompressionStatus2["COMPRESSED"] = 1] = "COMPRESSED";
-      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_INFLATED_TOKEN_COUNT"] = 2] = "COMPRESSION_FAILED_INFLATED_TOKEN_COUNT";
-      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_TOKEN_COUNT_ERROR"] = 3] = "COMPRESSION_FAILED_TOKEN_COUNT_ERROR";
-      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_EMPTY_SUMMARY"] = 4] = "COMPRESSION_FAILED_EMPTY_SUMMARY";
-      CompressionStatus2[CompressionStatus2["NOOP"] = 5] = "NOOP";
-    })(CompressionStatus || (CompressionStatus = {}));
-    Turn = class {
-      static {
-        __name(this, "Turn");
-      }
-      chat;
-      prompt_id;
-      pendingToolCalls = [];
-      debugResponses = [];
-      pendingCitations = /* @__PURE__ */ new Set();
-      finishReason = void 0;
-      currentResponseId;
-      constructor(chat, prompt_id) {
-        this.chat = chat;
-        this.prompt_id = prompt_id;
-      }
-      // The run method yields simpler events suitable for server logic
-      async *run(model, req, signal) {
-        try {
-          const rawStream = await this.chat.sendMessageStream(model, {
-            message: req,
-            config: {
-              abortSignal: signal
-            }
-          }, this.prompt_id);
-          const responseStream = withChunkTimeout(rawStream, STREAM_STALL_TIMEOUT_MS);
-          for await (const streamEvent of responseStream) {
-            if (signal?.aborted) {
-              yield { type: GeminiEventType.UserCancelled };
-              return;
-            }
-            if (streamEvent.type === "retry") {
-              yield {
-                type: GeminiEventType.Retry,
-                retryInfo: streamEvent.retryInfo
-              };
-              continue;
-            }
-            const resp = streamEvent.value;
-            if (!resp)
-              continue;
-            this.debugResponses.push(resp);
-            if (resp.responseId) {
-              this.currentResponseId = resp.responseId;
-            }
-            const thoughtText = getThoughtText(resp);
-            if (thoughtText) {
-              yield {
-                type: GeminiEventType.Thought,
-                value: parseThought(thoughtText)
-              };
-            }
-            const text = getResponseText(resp);
-            if (text) {
-              yield { type: GeminiEventType.Content, value: text };
-            }
-            const functionCalls = resp.functionCalls ?? [];
-            for (const fnCall of functionCalls) {
-              const event = this.handlePendingFunctionCall(fnCall);
-              if (event) {
-                yield event;
-              }
-            }
-            for (const citation of getCitations(resp)) {
-              this.pendingCitations.add(citation);
-            }
-            const finishReason = resp.candidates?.[0]?.finishReason;
-            if (finishReason) {
-              if (finishReason === FinishReason.MAX_TOKENS) {
-                for (const tc of this.pendingToolCalls) {
-                  tc.wasOutputTruncated = true;
-                }
-              }
-              if (this.pendingCitations.size > 0) {
-                yield {
-                  type: GeminiEventType.Citation,
-                  value: `Citations:
-${[...this.pendingCitations].sort().join("\n")}`
-                };
-                this.pendingCitations.clear();
-              }
-              this.finishReason = finishReason;
-              yield {
-                type: GeminiEventType.Finished,
-                value: {
-                  reason: finishReason,
-                  usageMetadata: resp.usageMetadata
-                }
-              };
-            }
-          }
-        } catch (e4) {
-          if (signal.aborted) {
-            yield { type: GeminiEventType.UserCancelled };
-            return;
-          }
-          if (e4 instanceof StreamStallError) {
-            yield {
-              type: GeminiEventType.Error,
-              value: {
-                error: {
-                  message: e4.message,
-                  status: void 0
-                }
-              }
-            };
-            return;
-          }
-          const error40 = toFriendlyError(e4);
-          if (error40 instanceof UnauthorizedError) {
-            throw error40;
-          }
-          const contextForReport = [...this.chat.getHistory(
-            /*curated*/
-            true
-          ), req];
-          await reportError2(error40, "Error when talking to API", contextForReport, "Turn.run-sendMessageStream");
-          const status = typeof error40 === "object" && error40 !== null && "status" in error40 && typeof error40.status === "number" ? error40.status : void 0;
-          const structuredError = {
-            message: getErrorMessage(error40),
-            status
-          };
-          await this.chat.maybeIncludeSchemaDepthContext(structuredError);
-          yield { type: GeminiEventType.Error, value: { error: structuredError } };
-          return;
-        }
-      }
-      handlePendingFunctionCall(fnCall) {
-        const callId = fnCall.id ?? `${fnCall.name}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-        const name4 = fnCall.name || "undefined_tool_name";
-        const args2 = fnCall.args || {};
-        const toolCallRequest = {
-          callId,
-          name: name4,
-          args: args2,
-          isClientInitiated: false,
-          prompt_id: this.prompt_id,
-          response_id: this.currentResponseId
-        };
-        this.pendingToolCalls.push(toolCallRequest);
-        return { type: GeminiEventType.ToolCallRequest, value: toolCallRequest };
-      }
-      getDebugResponses() {
-        return this.debugResponses;
-      }
-    };
-    __name(getCitations, "getCitations");
-  }
-});
-
 // packages/core/dist/src/hooks/types.js
 function getHookKey(hook) {
   const name4 = hook.name ?? "";
@@ -171710,13 +170565,13 @@ function createHookOutput(eventName, data) {
       return new DefaultHookOutput(data);
   }
 }
-var debugLogger25, HooksConfigSource, HookEventName, HOOKS_CONFIG_FIELDS, HookType, DefaultHookOutput, PreToolUseHookOutput, PostToolUseHookOutput, PostToolUseFailureHookOutput, StopHookOutput, PermissionRequestHookOutput, NotificationType, SessionStartSource, PermissionMode, SessionEndReason, PreCompactTrigger, AgentType;
+var debugLogger22, HooksConfigSource, HookEventName, HOOKS_CONFIG_FIELDS, HookType, DefaultHookOutput, PreToolUseHookOutput, PostToolUseHookOutput, PostToolUseFailureHookOutput, StopHookOutput, PermissionRequestHookOutput, NotificationType, SessionStartSource, PermissionMode, SessionEndReason, PreCompactTrigger, AgentType;
 var init_types6 = __esm({
   "packages/core/dist/src/hooks/types.js"() {
     "use strict";
     init_esbuild_shims();
     init_debugLogger();
-    debugLogger25 = createDebugLogger("TRUSTED_HOOKS");
+    debugLogger22 = createDebugLogger("TRUSTED_HOOKS");
     (function(HooksConfigSource2) {
       HooksConfigSource2["Project"] = "project";
       HooksConfigSource2["User"] = "user";
@@ -171888,10 +170743,10 @@ var init_types6 = __esm({
         this.decision = data.decision ?? "allow";
         this.reason = data.reason ?? "No reason provided";
         if (data.decision === void 0) {
-          debugLogger25.debug('PostToolUseHookOutput: No explicit decision set, defaulting to "allow"');
+          debugLogger22.debug('PostToolUseHookOutput: No explicit decision set, defaulting to "allow"');
         }
         if (data.reason === void 0) {
-          debugLogger25.debug('PostToolUseHookOutput: No explicit reason set, defaulting to "No reason provided"');
+          debugLogger22.debug('PostToolUseHookOutput: No explicit reason set, defaulting to "No reason provided"');
         }
       }
     };
@@ -172026,30 +170881,30 @@ __export(sessionNotes_exports, {
   readSessionNotes: () => readSessionNotes,
   updateSessionNoteSection: () => updateSessionNoteSection
 });
-import * as fs21 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as fs19 from "node:fs/promises";
+import * as path18 from "node:path";
 function getSessionNotesPath(projectDir) {
-  return path20.join(projectDir, ".proto", SESSION_NOTES_FILENAME);
+  return path18.join(projectDir, ".proto", SESSION_NOTES_FILENAME);
 }
 async function readSessionNotes(projectDir) {
   const filePath = getSessionNotesPath(projectDir);
   try {
-    return await fs21.readFile(filePath, "utf-8");
+    return await fs19.readFile(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 async function initSessionNotes(projectDir) {
   const filePath = getSessionNotesPath(projectDir);
-  await fs21.mkdir(path20.dirname(filePath), { recursive: true });
-  await fs21.writeFile(filePath, SESSION_NOTES_TEMPLATE, "utf-8");
+  await fs19.mkdir(path18.dirname(filePath), { recursive: true });
+  await fs19.writeFile(filePath, SESSION_NOTES_TEMPLATE, "utf-8");
   logger2.debug("Session notes initialized");
 }
 async function updateSessionNoteSection(projectDir, section, content) {
   const filePath = getSessionNotesPath(projectDir);
   let raw2;
   try {
-    raw2 = await fs21.readFile(filePath, "utf-8");
+    raw2 = await fs19.readFile(filePath, "utf-8");
   } catch {
     raw2 = SESSION_NOTES_TEMPLATE;
   }
@@ -172072,8 +170927,8 @@ async function updateSessionNoteSection(projectDir, section, content) {
   const updated = `${before}
 ${content.trim()}
 ${after}`;
-  await fs21.mkdir(path20.dirname(filePath), { recursive: true });
-  await fs21.writeFile(filePath, updated, "utf-8");
+  await fs19.mkdir(path18.dirname(filePath), { recursive: true });
+  await fs19.writeFile(filePath, updated, "utf-8");
 }
 async function clearSessionNotes(projectDir) {
   await initSessionNotes(projectDir);
@@ -172423,494 +171278,1817 @@ function applyMicrocompact(history, verbatimWindowSize = INCREMENTAL_PROTECTED_T
           ...part.functionResponse,
           response: { output: MICROCOMPACT_STUB }
         }
-      };
-    });
-    return { ...msg, parts: newParts };
-  });
-  return { newHistory, clearedCount };
-}
-function estimateMicrocompactSaving(history, verbatimWindowSize = INCREMENTAL_PROTECTED_TAIL) {
-  const original = JSON.stringify(history).length;
-  if (original === 0)
-    return 0;
-  const { newHistory } = applyMicrocompact(history, verbatimWindowSize);
-  const compacted = JSON.stringify(newHistory).length;
-  return Math.max(0, (original - compacted) / original);
-}
-var MICROCOMPACT_STUB;
-var init_microcompact = __esm({
-  "packages/core/dist/src/services/microcompact.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_chatCompressionService();
-    MICROCOMPACT_STUB = "[result cleared \u2014 see session notes for context]";
-    __name(applyMicrocompact, "applyMicrocompact");
-    __name(estimateMicrocompactSaving, "estimateMicrocompactSaving");
+      };
+    });
+    return { ...msg, parts: newParts };
+  });
+  return { newHistory, clearedCount };
+}
+function estimateMicrocompactSaving(history, verbatimWindowSize = INCREMENTAL_PROTECTED_TAIL) {
+  const original = JSON.stringify(history).length;
+  if (original === 0)
+    return 0;
+  const { newHistory } = applyMicrocompact(history, verbatimWindowSize);
+  const compacted = JSON.stringify(newHistory).length;
+  return Math.max(0, (original - compacted) / original);
+}
+var MICROCOMPACT_STUB;
+var init_microcompact = __esm({
+  "packages/core/dist/src/services/microcompact.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_chatCompressionService();
+    MICROCOMPACT_STUB = "[result cleared \u2014 see session notes for context]";
+    __name(applyMicrocompact, "applyMicrocompact");
+    __name(estimateMicrocompactSaving, "estimateMicrocompactSaving");
+  }
+});
+
+// packages/core/dist/src/services/chatCompressionService.js
+function applyObservationMask(history, verbatimWindowSize = INCREMENTAL_PROTECTED_TAIL) {
+  if (history.length <= verbatimWindowSize)
+    return history;
+  let pairsKept = 0;
+  let cutIndex = history.length;
+  for (let i4 = history.length - 1; i4 >= 0; i4--) {
+    const msg = history[i4];
+    if (msg?.role === "user" && msg.parts?.some((p2) => p2.functionResponse)) {
+      pairsKept++;
+      if (pairsKept >= verbatimWindowSize) {
+        cutIndex = i4;
+        break;
+      }
+    }
+  }
+  if (cutIndex === 0)
+    return history;
+  const maskedCount = history.slice(0, cutIndex).filter((m3) => m3.role === "user" && m3.parts?.some((p2) => p2.functionResponse) || m3.role === "model" && m3.parts?.some((p2) => p2.functionCall)).length;
+  const placeholder = {
+    role: "user",
+    parts: [
+      {
+        text: `[OBSERVATION_MASK: ${maskedCount} tool call/result pairs from earlier in the session have been masked to reduce context. The most recent ${verbatimWindowSize} pairs are preserved verbatim below.]`
+      }
+    ]
+  };
+  return [placeholder, ...history.slice(cutIndex)];
+}
+function extractContentText(content) {
+  if (!content.parts || content.parts.length === 0) {
+    return null;
+  }
+  const texts = content.parts.filter((part) => part.text !== void 0).map((part) => part.text);
+  if (texts.length === 0) {
+    return null;
+  }
+  return texts.join("");
+}
+function isCompressedMessage(content) {
+  const text = extractContentText(content);
+  return text !== null && text.startsWith(COMPRESSED_CONTEXT_PREFIX);
+}
+function findCompressSplitPoint(contents, fraction) {
+  if (fraction <= 0 || fraction >= 1) {
+    throw new Error("Fraction must be between 0 and 1");
+  }
+  const charCounts = contents.map((content) => JSON.stringify(content).length);
+  const totalCharCount = charCounts.reduce((a2, b2) => a2 + b2, 0);
+  const targetCharCount = totalCharCount * fraction;
+  let lastSplitPoint = 0;
+  let cumulativeCharCount = 0;
+  for (let i4 = 0; i4 < contents.length; i4++) {
+    const content = contents[i4];
+    if (content.role === "user" && !content.parts?.some((part) => !!part.functionResponse)) {
+      if (cumulativeCharCount >= targetCharCount) {
+        return i4;
+      }
+      lastSplitPoint = i4;
+    }
+    cumulativeCharCount += charCounts[i4];
+  }
+  const lastContent = contents[contents.length - 1];
+  if (lastContent?.role === "model" && !lastContent?.parts?.some((part) => part.functionCall)) {
+    return contents.length;
+  }
+  if (lastContent?.role === "user" && lastContent?.parts?.some((part) => !!part.functionResponse)) {
+    return contents.length;
+  }
+  return lastSplitPoint;
+}
+function estimateHistoryTokens(history) {
+  return Math.ceil(history.reduce((sum, entry) => sum + JSON.stringify(entry).length, 0) / 4);
+}
+function adjustIndexForToolPairs(history, startIndex) {
+  let idx = startIndex;
+  while (idx > 0) {
+    const msg = history[idx];
+    if (!msg)
+      break;
+    const isUserWithNoResponse = msg.role === "user" && !(msg.parts ?? []).some((p2) => "functionResponse" in p2);
+    const isModelWithNoCall = msg.role === "model" && !(msg.parts ?? []).some((p2) => "functionCall" in p2);
+    if (isUserWithNoResponse || isModelWithNoCall)
+      break;
+    idx--;
+  }
+  return idx;
+}
+var COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, INCREMENTAL_PROTECTED_TAIL, INCREMENTAL_MAX_CHUNK_SIZE, COMPRESSED_CONTEXT_PREFIX, MIN_COMPRESSION_FRACTION, ChatCompressionService;
+var init_chatCompressionService = __esm({
+  "packages/core/dist/src/services/chatCompressionService.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_turn();
+    init_uiTelemetry();
+    init_tokenLimits();
+    init_prompts();
+    init_partUtils();
+    init_loggers();
+    init_types4();
+    init_types6();
+    init_sessionNotes();
+    init_sessionMemoryUtils();
+    init_prompts2();
+    init_microcompact();
+    COMPRESSION_TOKEN_THRESHOLD = 0.7;
+    COMPRESSION_PRESERVE_THRESHOLD = 0.3;
+    INCREMENTAL_PROTECTED_TAIL = 10;
+    INCREMENTAL_MAX_CHUNK_SIZE = 20;
+    COMPRESSED_CONTEXT_PREFIX = "[COMPRESSED_CONTEXT]";
+    MIN_COMPRESSION_FRACTION = 0.05;
+    __name(applyObservationMask, "applyObservationMask");
+    __name(extractContentText, "extractContentText");
+    __name(isCompressedMessage, "isCompressedMessage");
+    __name(findCompressSplitPoint, "findCompressSplitPoint");
+    ChatCompressionService = class {
+      static {
+        __name(this, "ChatCompressionService");
+      }
+      async compress(chat, promptId, force, model, config2, hasFailedCompressionAttempt, signal) {
+        const curatedHistory = chat.getHistory(true);
+        const threshold = config2.getChatCompression()?.contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
+        if (curatedHistory.length === 0 || threshold <= 0 || hasFailedCompressionAttempt && !force) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount: 0,
+              newTokenCount: 0,
+              compressionStatus: CompressionStatus.NOOP
+            }
+          };
+        }
+        const originalTokenCount = uiTelemetryService.getLastPromptTokenCount();
+        if (!force) {
+          const contextLimit = config2.getContentGeneratorConfig()?.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
+          if (originalTokenCount < threshold * contextLimit) {
+            return {
+              newHistory: null,
+              info: {
+                originalTokenCount,
+                newTokenCount: originalTokenCount,
+                compressionStatus: CompressionStatus.NOOP
+              }
+            };
+          }
+        }
+        if (!force) {
+          const smResult = await this.trySessionMemoryCompaction(curatedHistory, originalTokenCount, config2);
+          if (smResult)
+            return smResult;
+        }
+        if (!force) {
+          const saving = estimateMicrocompactSaving(curatedHistory);
+          if (saving >= 0.2) {
+            const { newHistory: microHistory } = applyMicrocompact(curatedHistory);
+            const newTokenCount = Math.round(originalTokenCount * (1 - saving));
+            uiTelemetryService.setLastPromptTokenCount(newTokenCount);
+            return {
+              newHistory: microHistory,
+              info: {
+                originalTokenCount,
+                newTokenCount,
+                compressionStatus: CompressionStatus.COMPRESSED
+              }
+            };
+          }
+        }
+        const hookSystem = config2.getHookSystem();
+        if (hookSystem) {
+          const trigger = force ? PreCompactTrigger.Manual : PreCompactTrigger.Auto;
+          try {
+            await hookSystem.firePreCompactEvent(trigger, "", signal);
+          } catch (err3) {
+            config2.getDebugLogger().warn(`PreCompact hook failed: ${err3}`);
+          }
+        }
+        const incrementalResult = await this.compressIncremental(curatedHistory, model, config2, promptId, signal);
+        if (incrementalResult.compressed) {
+          return this.finalizeCompression(incrementalResult.newHistory, originalTokenCount, incrementalResult.compressionInputTokenCount, incrementalResult.compressionOutputTokenCount, model, config2, signal);
+        }
+        return this.compressFull(curatedHistory, originalTokenCount, model, config2, promptId, force, signal);
+      }
+      /**
+       * Incremental compression: protects the most recent messages and compresses
+       * the oldest uncompressed chunk. Each call compresses one chunk, making the
+       * operation idempotent and safe to call repeatedly.
+       */
+      async compressIncremental(history, model, config2, promptId, _signal) {
+        const protectedTailMessages = INCREMENTAL_PROTECTED_TAIL;
+        const maxChunkSize = INCREMENTAL_MAX_CHUNK_SIZE;
+        if (history.length <= protectedTailMessages + 2) {
+          return { newHistory: history, compressed: false };
+        }
+        const compressibleEnd = history.length - protectedTailMessages;
+        let chunkStart = 0;
+        while (chunkStart < compressibleEnd) {
+          if (isCompressedMessage(history[chunkStart])) {
+            chunkStart++;
+          } else {
+            break;
+          }
+        }
+        if (chunkStart >= compressibleEnd) {
+          return { newHistory: history, compressed: false };
+        }
+        const chunkEnd = Math.min(chunkStart + maxChunkSize, compressibleEnd);
+        const chunk = history.slice(chunkStart, chunkEnd);
+        const summaryResponse = await config2.getContentGenerator().generateContent({
+          model,
+          contents: [
+            ...chunk,
+            {
+              role: "user",
+              parts: [
+                {
+                  text: "Compress the conversation chunk above into a dense summary following the output format."
+                }
+              ]
+            }
+          ],
+          config: {
+            systemInstruction: getIncrementalCompressionPrompt()
+          }
+        }, promptId);
+        const summary = getResponseText(summaryResponse) ?? "";
+        if (!summary || summary.trim().length === 0) {
+          return { newHistory: history, compressed: false };
+        }
+        const prefixedSummary = summary.startsWith(COMPRESSED_CONTEXT_PREFIX) ? summary : `${COMPRESSED_CONTEXT_PREFIX}
+${summary}`;
+        const usageMetadata = summaryResponse.usageMetadata;
+        const inputTokenCount = usageMetadata?.promptTokenCount;
+        let outputTokenCount = usageMetadata?.candidatesTokenCount;
+        if (outputTokenCount === void 0 && typeof usageMetadata?.totalTokenCount === "number" && typeof inputTokenCount === "number") {
+          outputTokenCount = Math.max(0, usageMetadata.totalTokenCount - inputTokenCount);
+        }
+        const summaryMessage = {
+          role: "user",
+          parts: [{ text: prefixedSummary }]
+        };
+        const summaryAck = {
+          role: "model",
+          parts: [{ text: "Understood. Incremental context loaded." }]
+        };
+        const newHistory = [
+          ...history.slice(0, chunkStart),
+          summaryMessage,
+          summaryAck,
+          ...history.slice(chunkEnd)
+        ];
+        return {
+          newHistory,
+          compressed: true,
+          compressionInputTokenCount: inputTokenCount,
+          compressionOutputTokenCount: outputTokenCount
+        };
+      }
+      /**
+       * Original full-history compression using getCompressionPrompt().
+       * Used as a fallback when history is too short for incremental compression.
+       */
+      async compressFull(curatedHistory, originalTokenCount, model, config2, promptId, force, signal) {
+        const lastMessage = curatedHistory[curatedHistory.length - 1];
+        const hasOrphanedFuncCall = force && lastMessage?.role === "model" && lastMessage.parts?.some((p2) => !!p2.functionCall);
+        const historyForSplit = hasOrphanedFuncCall ? curatedHistory.slice(0, -1) : curatedHistory;
+        const splitPoint = findCompressSplitPoint(historyForSplit, 1 - COMPRESSION_PRESERVE_THRESHOLD);
+        const historyToCompress = historyForSplit.slice(0, splitPoint);
+        const historyToKeep = historyForSplit.slice(splitPoint);
+        if (historyToCompress.length === 0) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.NOOP
+            }
+          };
+        }
+        const compressCharCount = historyToCompress.reduce((sum, c4) => sum + JSON.stringify(c4).length, 0);
+        const totalCharCount = historyForSplit.reduce((sum, c4) => sum + JSON.stringify(c4).length, 0);
+        if (totalCharCount > 0 && compressCharCount / totalCharCount < MIN_COMPRESSION_FRACTION) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.NOOP
+            }
+          };
+        }
+        const summaryResponse = await config2.getContentGenerator().generateContent({
+          model,
+          contents: [
+            ...historyToCompress,
+            {
+              role: "user",
+              parts: [
+                {
+                  text: "Generate the <summary> now. Be maximally concise \u2014 every token counts."
+                }
+              ]
+            }
+          ],
+          config: {
+            systemInstruction: getCompressionPrompt()
+          }
+        }, promptId);
+        const summary = getResponseText(summaryResponse) ?? "";
+        const prefixedSummary = summary && summary.trim().length > 0 ? summary.startsWith(COMPRESSED_CONTEXT_PREFIX) ? summary : `${COMPRESSED_CONTEXT_PREFIX}
+${summary}` : summary;
+        const compressionUsageMetadata = summaryResponse.usageMetadata;
+        const compressionInputTokenCount = compressionUsageMetadata?.promptTokenCount;
+        let compressionOutputTokenCount = compressionUsageMetadata?.candidatesTokenCount;
+        if (compressionOutputTokenCount === void 0 && typeof compressionUsageMetadata?.totalTokenCount === "number" && typeof compressionInputTokenCount === "number") {
+          compressionOutputTokenCount = Math.max(0, compressionUsageMetadata.totalTokenCount - compressionInputTokenCount);
+        }
+        const isSummaryEmpty = !prefixedSummary || prefixedSummary.trim().length === 0;
+        let extraHistory = [];
+        if (!isSummaryEmpty) {
+          extraHistory = [
+            {
+              role: "user",
+              parts: [{ text: prefixedSummary }]
+            },
+            {
+              role: "model",
+              parts: [{ text: "Got it. Thanks for the additional context!" }]
+            },
+            ...historyToKeep
+          ];
+        }
+        return this.finalizeCompression(isSummaryEmpty ? null : extraHistory, originalTokenCount, compressionInputTokenCount, compressionOutputTokenCount, model, config2, signal, isSummaryEmpty);
+      }
+      /**
+       * Shared finalization logic for both incremental and full compression.
+       * Handles token math, telemetry, hook firing, and status determination.
+       */
+      async finalizeCompression(newHistory, originalTokenCount, compressionInputTokenCount, compressionOutputTokenCount, model, config2, signal, isSummaryEmpty = false) {
+        let newTokenCount = originalTokenCount;
+        let canCalculateNewTokenCount = false;
+        if (!isSummaryEmpty && newHistory) {
+          if (typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
+            canCalculateNewTokenCount = true;
+            newTokenCount = Math.max(0, originalTokenCount - (compressionInputTokenCount - 1e3) + compressionOutputTokenCount);
+          }
+        }
+        logChatCompression(config2, makeChatCompressionEvent({
+          tokens_before: originalTokenCount,
+          tokens_after: newTokenCount,
+          compression_input_token_count: compressionInputTokenCount,
+          compression_output_token_count: compressionOutputTokenCount
+        }));
+        if (isSummaryEmpty) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSION_FAILED_EMPTY_SUMMARY
+            }
+          };
+        } else if (!canCalculateNewTokenCount) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR
+            }
+          };
+        } else if (newTokenCount > originalTokenCount) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT
+            }
+          };
+        } else {
+          uiTelemetryService.setLastPromptTokenCount(newTokenCount);
+          try {
+            const permissionMode = String(config2.getApprovalMode());
+            await config2.getHookSystem()?.fireSessionStartEvent(SessionStartSource.Compact, model ?? "", permissionMode, void 0, signal);
+          } catch (err3) {
+            config2.getDebugLogger().warn(`SessionStart hook failed: ${err3}`);
+          }
+          return {
+            newHistory,
+            info: {
+              originalTokenCount,
+              newTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSED
+            }
+          };
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // Session Memory fast-path compaction
+      // ---------------------------------------------------------------------------
+      /**
+       * Attempt to compact using the continuously-maintained session notes file
+       * instead of making a fresh LLM summarisation call.
+       *
+       * Returns null when the notes are absent, empty, or would not meaningfully
+       * reduce the context (≥ 90 % of original tokens), causing the caller to fall
+       * through to the normal LLM compression pipeline.
+       */
+      async trySessionMemoryCompaction(history, originalTokenCount, config2) {
+        try {
+          await waitForExtraction();
+          const projectDir = config2.getProjectRoot();
+          const notes = await readSessionNotes(projectDir);
+          if (!notes || isSessionNotesEmpty(notes))
+            return null;
+          const { truncated, wasTruncated } = truncateNotesForCompact(notes);
+          const summaryText = `[SESSION_MEMORY_SUMMARY]
+The following is a running summary of this conversation maintained by the session memory agent.
+` + (wasTruncated ? `(Some sections were truncated for length. Full notes at ${config2.getProjectRoot()}/.proto/session-notes.md)
+` : "") + `
+${truncated}`;
+          const MIN_PRESERVED_TOKENS = 1e4;
+          const lastSummarized = getLastSummarizedCursorIndex();
+          let keepFromIndex = lastSummarized >= 0 ? lastSummarized + 1 : history.length;
+          let preservedTokens = estimateHistoryTokens(history.slice(keepFromIndex));
+          while (keepFromIndex > 0 && preservedTokens < MIN_PRESERVED_TOKENS) {
+            keepFromIndex--;
+            preservedTokens += estimateHistoryTokens([history[keepFromIndex]]);
+          }
+          keepFromIndex = adjustIndexForToolPairs(history, keepFromIndex);
+          const preservedTail = history.slice(keepFromIndex);
+          const summaryUserMsg = {
+            role: "user",
+            parts: [{ text: summaryText }]
+          };
+          const summaryAckMsg = {
+            role: "model",
+            parts: [
+              {
+                text: "Understood. I have the session summary and will continue from the current state."
+              }
+            ]
+          };
+          const newHistory = [summaryUserMsg, summaryAckMsg, ...preservedTail];
+          const newTokenCount = estimateHistoryTokens(newHistory);
+          if (newTokenCount >= originalTokenCount * 0.9)
+            return null;
+          return {
+            newHistory,
+            info: {
+              originalTokenCount,
+              newTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSED
+            }
+          };
+        } catch {
+          return null;
+        }
+      }
+    };
+    __name(estimateHistoryTokens, "estimateHistoryTokens");
+    __name(adjustIndexForToolPairs, "adjustIndexForToolPairs");
+  }
+});
+
+// node_modules/async-mutex/index.mjs
+function insertSorted(a2, v2) {
+  const i4 = findIndexFromEnd(a2, (other2) => v2.priority <= other2.priority);
+  a2.splice(i4 + 1, 0, v2);
+}
+function findIndexFromEnd(a2, predicate) {
+  for (let i4 = a2.length - 1; i4 >= 0; i4--) {
+    if (predicate(a2[i4])) {
+      return i4;
+    }
+  }
+  return -1;
+}
+var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2, Semaphore, __awaiter$1, Mutex;
+var init_async_mutex = __esm({
+  "node_modules/async-mutex/index.mjs"() {
+    init_esbuild_shims();
+    E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+    E_ALREADY_LOCKED = new Error("mutex already locked");
+    E_CANCELED = new Error("request for lock canceled");
+    __awaiter$2 = function(thisArg, _arguments, P2, generator) {
+      function adopt(value) {
+        return value instanceof P2 ? value : new P2(function(resolve37) {
+          resolve37(value);
+        });
+      }
+      __name(adopt, "adopt");
+      return new (P2 || (P2 = Promise))(function(resolve37, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e4) {
+            reject(e4);
+          }
+        }
+        __name(fulfilled, "fulfilled");
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e4) {
+            reject(e4);
+          }
+        }
+        __name(rejected, "rejected");
+        function step(result) {
+          result.done ? resolve37(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        __name(step, "step");
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Semaphore = class {
+      static {
+        __name(this, "Semaphore");
+      }
+      constructor(_value, _cancelError = E_CANCELED) {
+        this._value = _value;
+        this._cancelError = _cancelError;
+        this._queue = [];
+        this._weightedWaiters = [];
+      }
+      acquire(weight = 1, priority = 0) {
+        if (weight <= 0)
+          throw new Error(`invalid weight ${weight}: must be positive`);
+        return new Promise((resolve37, reject) => {
+          const task = { resolve: resolve37, reject, weight, priority };
+          const i4 = findIndexFromEnd(this._queue, (other2) => priority <= other2.priority);
+          if (i4 === -1 && weight <= this._value) {
+            this._dispatchItem(task);
+          } else {
+            this._queue.splice(i4 + 1, 0, task);
+          }
+        });
+      }
+      runExclusive(callback_1) {
+        return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
+          const [value, release2] = yield this.acquire(weight, priority);
+          try {
+            return yield callback(value);
+          } finally {
+            release2();
+          }
+        });
+      }
+      waitForUnlock(weight = 1, priority = 0) {
+        if (weight <= 0)
+          throw new Error(`invalid weight ${weight}: must be positive`);
+        if (this._couldLockImmediately(weight, priority)) {
+          return Promise.resolve();
+        } else {
+          return new Promise((resolve37) => {
+            if (!this._weightedWaiters[weight - 1])
+              this._weightedWaiters[weight - 1] = [];
+            insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve37, priority });
+          });
+        }
+      }
+      isLocked() {
+        return this._value <= 0;
+      }
+      getValue() {
+        return this._value;
+      }
+      setValue(value) {
+        this._value = value;
+        this._dispatchQueue();
+      }
+      release(weight = 1) {
+        if (weight <= 0)
+          throw new Error(`invalid weight ${weight}: must be positive`);
+        this._value += weight;
+        this._dispatchQueue();
+      }
+      cancel() {
+        this._queue.forEach((entry) => entry.reject(this._cancelError));
+        this._queue = [];
+      }
+      _dispatchQueue() {
+        this._drainUnlockWaiters();
+        while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+          this._dispatchItem(this._queue.shift());
+          this._drainUnlockWaiters();
+        }
+      }
+      _dispatchItem(item) {
+        const previousValue = this._value;
+        this._value -= item.weight;
+        item.resolve([previousValue, this._newReleaser(item.weight)]);
+      }
+      _newReleaser(weight) {
+        let called = false;
+        return () => {
+          if (called)
+            return;
+          called = true;
+          this.release(weight);
+        };
+      }
+      _drainUnlockWaiters() {
+        if (this._queue.length === 0) {
+          for (let weight = this._value; weight > 0; weight--) {
+            const waiters = this._weightedWaiters[weight - 1];
+            if (!waiters)
+              continue;
+            waiters.forEach((waiter) => waiter.resolve());
+            this._weightedWaiters[weight - 1] = [];
+          }
+        } else {
+          const queuedPriority = this._queue[0].priority;
+          for (let weight = this._value; weight > 0; weight--) {
+            const waiters = this._weightedWaiters[weight - 1];
+            if (!waiters)
+              continue;
+            const i4 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+            (i4 === -1 ? waiters : waiters.splice(0, i4)).forEach((waiter) => waiter.resolve());
+          }
+        }
+      }
+      _couldLockImmediately(weight, priority) {
+        return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+      }
+    };
+    __name(insertSorted, "insertSorted");
+    __name(findIndexFromEnd, "findIndexFromEnd");
+    __awaiter$1 = function(thisArg, _arguments, P2, generator) {
+      function adopt(value) {
+        return value instanceof P2 ? value : new P2(function(resolve37) {
+          resolve37(value);
+        });
+      }
+      __name(adopt, "adopt");
+      return new (P2 || (P2 = Promise))(function(resolve37, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e4) {
+            reject(e4);
+          }
+        }
+        __name(fulfilled, "fulfilled");
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e4) {
+            reject(e4);
+          }
+        }
+        __name(rejected, "rejected");
+        function step(result) {
+          result.done ? resolve37(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        __name(step, "step");
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Mutex = class {
+      static {
+        __name(this, "Mutex");
+      }
+      constructor(cancelError) {
+        this._semaphore = new Semaphore(1, cancelError);
+      }
+      acquire() {
+        return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
+          const [, releaser] = yield this._semaphore.acquire(1, priority);
+          return releaser;
+        });
+      }
+      runExclusive(callback, priority = 0) {
+        return this._semaphore.runExclusive(() => callback(), 1, priority);
+      }
+      isLocked() {
+        return this._semaphore.isLocked();
+      }
+      waitForUnlock(priority = 0) {
+        return this._semaphore.waitForUnlock(1, priority);
+      }
+      release() {
+        if (this._semaphore.isLocked())
+          this._semaphore.release();
+      }
+      cancel() {
+        return this._semaphore.cancel();
+      }
+    };
+  }
+});
+
+// packages/core/dist/src/utils/jsonl-utils.js
+import fs20 from "node:fs";
+import path19 from "node:path";
+import readline from "node:readline";
+function getFileLock(filePath) {
+  if (!fileLocks.has(filePath)) {
+    fileLocks.set(filePath, new Mutex());
+  }
+  return fileLocks.get(filePath);
+}
+async function readLines(filePath, count) {
+  try {
+    const fileStream = fs20.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    const results = [];
+    for await (const line of rl) {
+      if (results.length >= count)
+        break;
+      const trimmed2 = line.trim();
+      if (trimmed2.length > 0) {
+        results.push(JSON.parse(trimmed2));
+      }
+    }
+    return results;
+  } catch (error40) {
+    if (error40.code !== "ENOENT") {
+      debugLogger23.error(`Error reading first ${count} lines from ${filePath}:`, error40);
+    }
+    return [];
+  }
+}
+async function read(filePath) {
+  try {
+    const fileStream = fs20.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    const results = [];
+    for await (const line of rl) {
+      const trimmed2 = line.trim();
+      if (trimmed2.length > 0) {
+        results.push(JSON.parse(trimmed2));
+      }
+    }
+    return results;
+  } catch (error40) {
+    if (error40.code !== "ENOENT") {
+      debugLogger23.error(`Error reading ${filePath}:`, error40);
+    }
+    return [];
+  }
+}
+async function writeLine(filePath, data) {
+  const lock = getFileLock(filePath);
+  await lock.runExclusive(() => {
+    const line = `${JSON.stringify(data)}
+`;
+    const dir = path19.dirname(filePath);
+    if (!fs20.existsSync(dir)) {
+      fs20.mkdirSync(dir, { recursive: true });
+    }
+    fs20.appendFileSync(filePath, line, "utf8");
+  });
+}
+function writeLineSync(filePath, data) {
+  const line = `${JSON.stringify(data)}
+`;
+  const dir = path19.dirname(filePath);
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
+  }
+  fs20.appendFileSync(filePath, line, "utf8");
+}
+function write(filePath, data) {
+  const lines = data.map((item) => JSON.stringify(item)).join("\n");
+  const dir = path19.dirname(filePath);
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
+  }
+  fs20.writeFileSync(filePath, `${lines}
+`, "utf8");
+}
+async function countLines(filePath) {
+  try {
+    const fileStream = fs20.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let count = 0;
+    for await (const line of rl) {
+      if (line.trim().length > 0) {
+        count++;
+      }
+    }
+    return count;
+  } catch (error40) {
+    if (error40.code !== "ENOENT") {
+      debugLogger23.error(`Error counting lines in ${filePath}:`, error40);
+    }
+    return 0;
+  }
+}
+function exists(filePath) {
+  try {
+    const stats = fs20.statSync(filePath);
+    return stats.isFile() && stats.size > 0;
+  } catch {
+    return false;
+  }
+}
+var debugLogger23, fileLocks;
+var init_jsonl_utils = __esm({
+  "packages/core/dist/src/utils/jsonl-utils.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_async_mutex();
+    init_debugLogger();
+    debugLogger23 = createDebugLogger("JSONL");
+    fileLocks = /* @__PURE__ */ new Map();
+    __name(getFileLock, "getFileLock");
+    __name(readLines, "readLines");
+    __name(read, "read");
+    __name(writeLine, "writeLine");
+    __name(writeLineSync, "writeLineSync");
+    __name(write, "write");
+    __name(countLines, "countLines");
+    __name(exists, "exists");
+  }
+});
+
+// packages/core/dist/src/services/chatRecordingService.js
+import path20 from "node:path";
+import fs21 from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var debugLogger24, ChatRecordingService;
+var init_chatRecordingService = __esm({
+  "packages/core/dist/src/services/chatRecordingService.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_config3();
+    init_node();
+    init_jsonl_utils();
+    init_gitUtils();
+    init_debugLogger();
+    debugLogger24 = createDebugLogger("CHAT_RECORDING");
+    ChatRecordingService = class {
+      static {
+        __name(this, "ChatRecordingService");
+      }
+      /** UUID of the last written record in the chain */
+      lastRecordUuid = null;
+      config;
+      /** In-memory cache of the current session's custom title (for re-append on exit) */
+      currentCustomTitle;
+      constructor(config2) {
+        this.config = config2;
+        this.lastRecordUuid = config2.getResumedSessionData()?.lastCompletedUuid ?? null;
+        if (config2.getResumedSessionData()) {
+          try {
+            const sessionService = config2.getSessionService();
+            this.currentCustomTitle = sessionService.getSessionTitle(config2.getSessionId());
+            this.finalize();
+          } catch {
+          }
+        }
+      }
+      /**
+       * Returns the session ID.
+       * @returns The session ID.
+       */
+      getSessionId() {
+        return this.config.getSessionId();
+      }
+      /**
+       * Ensures the chats directory exists, creating it if it doesn't exist.
+       * @returns The path to the chats directory.
+       * @throws Error if the directory cannot be created.
+       */
+      ensureChatsDir() {
+        const projectDir = this.config.storage.getProjectDir();
+        const chatsDir = path20.join(projectDir, "chats");
+        try {
+          fs21.mkdirSync(chatsDir, { recursive: true });
+        } catch {
+        }
+        return chatsDir;
+      }
+      /**
+       * Ensures the conversation file exists, creating it if it doesn't exist.
+       * Uses atomic file creation to avoid race conditions.
+       * @returns The path to the conversation file.
+       * @throws Error if the file cannot be created or accessed.
+       */
+      ensureConversationFile() {
+        const chatsDir = this.ensureChatsDir();
+        const sessionId = this.getSessionId();
+        const safeFilename = `${sessionId}.jsonl`;
+        const conversationFile = path20.join(chatsDir, safeFilename);
+        if (fs21.existsSync(conversationFile)) {
+          return conversationFile;
+        }
+        try {
+          fs21.writeFileSync(conversationFile, "", { flag: "wx", encoding: "utf8" });
+        } catch (error40) {
+          const nodeError = error40;
+          if (nodeError.code !== "EEXIST") {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            throw new Error(`Failed to create conversation file at ${conversationFile}: ${message}`);
+          }
+        }
+        return conversationFile;
+      }
+      /**
+       * Creates base fields for a ChatRecord.
+       */
+      createBaseRecord(type) {
+        return {
+          uuid: randomUUID2(),
+          parentUuid: this.lastRecordUuid,
+          sessionId: this.getSessionId(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type,
+          cwd: this.config.getProjectRoot(),
+          version: this.config.getCliVersion() || "unknown",
+          gitBranch: getGitBranch(this.config.getProjectRoot())
+        };
+      }
+      /**
+       * Appends a record to the session file and updates lastRecordUuid.
+       */
+      appendRecord(record2) {
+        try {
+          const conversationFile = this.ensureConversationFile();
+          writeLineSync(conversationFile, record2);
+          this.lastRecordUuid = record2.uuid;
+        } catch (error40) {
+          debugLogger24.error("Error appending record:", error40);
+          throw error40;
+        }
+      }
+      /**
+       * Records a user message.
+       * Writes immediately to disk.
+       *
+       * @param message The raw PartListUnion object as used with the API
+       */
+      recordUserMessage(message) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("user"),
+            message: createUserContent(message)
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving user message:", error40);
+        }
+      }
+      /**
+       * Records an assistant turn with all available data.
+       * Writes immediately to disk.
+       *
+       * @param data.message The raw PartListUnion object from the model response
+       * @param data.model The model name
+       * @param data.tokens Token usage statistics
+       * @param data.contextWindowSize Context window size of the model
+       * @param data.toolCallsMetadata Enriched tool call info for UI recovery
+       */
+      recordAssistantTurn(data) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("assistant"),
+            model: data.model
+          };
+          if (data.message !== void 0) {
+            record2.message = createModelContent(data.message);
+          }
+          if (data.tokens) {
+            record2.usageMetadata = data.tokens;
+          }
+          if (data.contextWindowSize !== void 0) {
+            record2.contextWindowSize = data.contextWindowSize;
+          }
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving assistant turn:", error40);
+        }
+      }
+      /**
+       * Records tool results (function responses) sent back to the model.
+       * Writes immediately to disk.
+       *
+       * @param message The raw PartListUnion object with functionResponse parts
+       * @param toolCallResult Optional tool call result info for UI recovery
+       */
+      recordToolResult(message, toolCallResult) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("tool_result"),
+            message: createUserContent(message)
+          };
+          if (toolCallResult) {
+            if (typeof toolCallResult.resultDisplay === "object" && toolCallResult.resultDisplay !== null && "type" in toolCallResult.resultDisplay && toolCallResult.resultDisplay.type === "task_execution") {
+              const taskResult = toolCallResult.resultDisplay;
+              record2.toolCallResult = {
+                ...toolCallResult,
+                resultDisplay: {
+                  ...taskResult,
+                  toolCalls: []
+                }
+              };
+            } else {
+              record2.toolCallResult = toolCallResult;
+            }
+          }
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving tool result:", error40);
+        }
+      }
+      /**
+       * Records a slash command invocation as a system record. This keeps the model
+       * history clean while allowing resume to replay UI output for commands like
+       * /about.
+       */
+      recordSlashCommand(payload) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "slash_command",
+            systemPayload: payload
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving slash command record:", error40);
+        }
+      }
+      /**
+       * Records a chat compression checkpoint as a system record. This keeps the UI
+       * history immutable while allowing resume/continue flows to reconstruct the
+       * compressed model-facing history from the stored snapshot.
+       */
+      recordChatCompression(payload) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "chat_compression",
+            systemPayload: payload
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving chat compression record:", error40);
+        }
+      }
+      /**
+       * Records a UI telemetry event for replaying metrics on resume.
+       */
+      recordUiTelemetryEvent(uiEvent) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "ui_telemetry",
+            systemPayload: { uiEvent }
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving ui telemetry record:", error40);
+        }
+      }
+      /**
+       * Records a custom title for the session (set via /rename).
+       * Appended as a system record so it persists with the session data.
+       * Also caches the title in memory for re-append on shutdown.
+       *
+       * @returns true if the record was written successfully, false on I/O error.
+       */
+      recordCustomTitle(customTitle) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "custom_title",
+            systemPayload: { customTitle }
+          };
+          this.appendRecord(record2);
+          this.currentCustomTitle = customTitle;
+          return true;
+        } catch (error40) {
+          debugLogger24.error("Error saving custom title record:", error40);
+          return false;
+        }
+      }
+      /**
+       * Finalizes the current session by re-appending cached metadata to EOF.
+       *
+       * Call this whenever leaving the current session — whether switching to
+       * another session, shutting down the process, or any other transition.
+       * This single entry point replaces scattered re-append calls and ensures
+       * the custom_title record stays within the last 64KB tail window that
+       * readSessionTitleFromFile() scans.
+       *
+       * Best-effort: errors are logged but never thrown.
+       */
+      finalize() {
+        if (!this.currentCustomTitle) {
+          return;
+        }
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "custom_title",
+            systemPayload: { customTitle: this.currentCustomTitle }
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error finalizing session metadata:", error40);
+        }
+      }
+      /**
+       * Records @-command metadata as a system record for UI reconstruction.
+       */
+      recordAtCommand(payload) {
+        try {
+          const record2 = {
+            ...this.createBaseRecord("system"),
+            type: "system",
+            subtype: "at_command",
+            systemPayload: payload
+          };
+          this.appendRecord(record2);
+        } catch (error40) {
+          debugLogger24.error("Error saving @-command record:", error40);
+        }
+      }
+    };
   }
 });
 
-// packages/core/dist/src/services/chatCompressionService.js
-function applyObservationMask(history, verbatimWindowSize = INCREMENTAL_PROTECTED_TAIL) {
-  if (history.length <= verbatimWindowSize)
-    return history;
-  let pairsKept = 0;
-  let cutIndex = history.length;
-  for (let i4 = history.length - 1; i4 >= 0; i4--) {
-    const msg = history[i4];
-    if (msg?.role === "user" && msg.parts?.some((p2) => p2.functionResponse)) {
-      pairsKept++;
-      if (pairsKept >= verbatimWindowSize) {
-        cutIndex = i4;
-        break;
-      }
-    }
+// packages/core/dist/src/core/geminiChat.js
+function isValidResponse2(response) {
+  if (response.usageMetadata) {
+    return true;
   }
-  if (cutIndex === 0)
-    return history;
-  const maskedCount = history.slice(0, cutIndex).filter((m3) => m3.role === "user" && m3.parts?.some((p2) => p2.functionResponse) || m3.role === "model" && m3.parts?.some((p2) => p2.functionCall)).length;
-  const placeholder = {
-    role: "user",
-    parts: [
-      {
-        text: `[OBSERVATION_MASK: ${maskedCount} tool call/result pairs from earlier in the session have been masked to reduce context. The most recent ${verbatimWindowSize} pairs are preserved verbatim below.]`
-      }
-    ]
-  };
-  return [placeholder, ...history.slice(cutIndex)];
-}
-function extractContentText(content) {
-  if (!content.parts || content.parts.length === 0) {
-    return null;
+  if (response.candidates === void 0 || response.candidates.length === 0) {
+    return false;
   }
-  const texts = content.parts.filter((part) => part.text !== void 0).map((part) => part.text);
-  if (texts.length === 0) {
-    return null;
+  if (response.candidates.some((candidate) => candidate.finishReason)) {
+    return true;
   }
-  return texts.join("");
+  const content = response.candidates[0]?.content;
+  return content !== void 0 && isValidContent2(content);
 }
-function isCompressedMessage(content) {
-  const text = extractContentText(content);
-  return text !== null && text.startsWith(COMPRESSED_CONTEXT_PREFIX);
+function isValidNonThoughtTextPart(part) {
+  return typeof part.text === "string" && !part.thought && !part.thoughtSignature && // Technically, the model should never generate parts that have text and
+  //  any of these but we don't trust them so check anyways.
+  !part.functionCall && !part.functionResponse && !part.inlineData && !part.fileData;
 }
-function findCompressSplitPoint(contents, fraction) {
-  if (fraction <= 0 || fraction >= 1) {
-    throw new Error("Fraction must be between 0 and 1");
+function isValidContent2(content) {
+  if (content.parts === void 0 || content.parts.length === 0) {
+    return false;
   }
-  const charCounts = contents.map((content) => JSON.stringify(content).length);
-  const totalCharCount = charCounts.reduce((a2, b2) => a2 + b2, 0);
-  const targetCharCount = totalCharCount * fraction;
-  let lastSplitPoint = 0;
-  let cumulativeCharCount = 0;
-  for (let i4 = 0; i4 < contents.length; i4++) {
-    const content = contents[i4];
-    if (content.role === "user" && !content.parts?.some((part) => !!part.functionResponse)) {
-      if (cumulativeCharCount >= targetCharCount) {
-        return i4;
-      }
-      lastSplitPoint = i4;
+  for (const part of content.parts) {
+    if (part === void 0 || Object.keys(part).length === 0) {
+      return false;
+    }
+    if (!isValidContentPart(part)) {
+      return false;
     }
-    cumulativeCharCount += charCounts[i4];
   }
-  const lastContent = contents[contents.length - 1];
-  if (lastContent?.role === "model" && !lastContent?.parts?.some((part) => part.functionCall)) {
-    return contents.length;
+  return true;
+}
+function isValidContentPart(part) {
+  const isInvalid = !part.thought && !part.thoughtSignature && part.text !== void 0 && part.text === "" && part.functionCall === void 0;
+  return !isInvalid;
+}
+function validateHistory2(history) {
+  for (const content of history) {
+    if (content.role !== "user" && content.role !== "model") {
+      throw new Error(`Role must be user or model, but got ${content.role}.`);
+    }
   }
-  if (lastContent?.role === "user" && lastContent?.parts?.some((part) => !!part.functionResponse)) {
-    return contents.length;
+}
+function extractCuratedHistory2(comprehensiveHistory) {
+  if (comprehensiveHistory === void 0 || comprehensiveHistory.length === 0) {
+    return [];
   }
-  return lastSplitPoint;
+  const curatedHistory = [];
+  const length = comprehensiveHistory.length;
+  let i4 = 0;
+  while (i4 < length) {
+    if (comprehensiveHistory[i4].role === "user") {
+      curatedHistory.push(comprehensiveHistory[i4]);
+      i4++;
+    } else {
+      const modelOutput = [];
+      let isValid2 = true;
+      while (i4 < length && comprehensiveHistory[i4].role === "model") {
+        modelOutput.push(comprehensiveHistory[i4]);
+        if (isValid2 && !isValidContent2(comprehensiveHistory[i4])) {
+          isValid2 = false;
+        }
+        i4++;
+      }
+      if (isValid2) {
+        curatedHistory.push(...modelOutput);
+      }
+    }
+  }
+  return curatedHistory;
 }
-function estimateHistoryTokens(history) {
-  return Math.ceil(history.reduce((sum, entry) => sum + JSON.stringify(entry).length, 0) / 4);
+function hasTruncationCascade(contents) {
+  if (contents.length === 0)
+    return false;
+  const last2 = contents[contents.length - 1];
+  if (last2.role !== "user")
+    return false;
+  return last2.parts?.some((p2) => {
+    const err3 = p2.functionResponse?.response?.["error"];
+    return typeof err3 === "string" && err3.includes(TRUNCATION_CASCADE_MARKER);
+  }) ?? false;
 }
-function adjustIndexForToolPairs(history, startIndex) {
-  let idx = startIndex;
-  while (idx > 0) {
-    const msg = history[idx];
-    if (!msg)
+function trimLargeToolResponsesFromContext(contents) {
+  return contents.map((content) => {
+    if (content.role !== "user" || !content.parts)
+      return content;
+    const needsTrim = content.parts.some((p2) => {
+      const out2 = p2.functionResponse?.response?.["output"];
+      return typeof out2 === "string" && out2.length > LARGE_TOOL_RESPONSE_TRIM_CHARS;
+    });
+    if (!needsTrim)
+      return content;
+    return {
+      ...content,
+      parts: content.parts.map((p2) => {
+        const out2 = p2.functionResponse?.response?.["output"];
+        if (typeof out2 !== "string" || out2.length <= LARGE_TOOL_RESPONSE_TRIM_CHARS)
+          return p2;
+        const trimmed2 = out2.slice(0, LARGE_TOOL_RESPONSE_TRIM_CHARS) + `
+
+[... output trimmed from ${out2.length} to ${LARGE_TOOL_RESPONSE_TRIM_CHARS} chars to reduce context size ...]`;
+        return {
+          ...p2,
+          functionResponse: {
+            ...p2.functionResponse,
+            response: {
+              ...p2.functionResponse.response,
+              output: trimmed2
+            }
+          }
+        };
+      })
+    };
+  });
+}
+function trimToolErrorsFromContext(contents, maxTrimPairs = 6) {
+  const trimmed2 = [...contents];
+  let trimmed_count = 0;
+  while (trimmed2.length >= 2 && trimmed_count < maxTrimPairs) {
+    const last2 = trimmed2[trimmed2.length - 1];
+    const prev = trimmed2[trimmed2.length - 2];
+    if (last2.role !== "user")
       break;
-    const isUserWithNoResponse = msg.role === "user" && !(msg.parts ?? []).some((p2) => "functionResponse" in p2);
-    const isModelWithNoCall = msg.role === "model" && !(msg.parts ?? []).some((p2) => "functionCall" in p2);
-    if (isUserWithNoResponse || isModelWithNoCall)
+    const allErrors = last2.parts?.every((p2) => p2.functionResponse !== void 0 && typeof p2.functionResponse.response?.["error"] === "string");
+    if (!allErrors)
       break;
-    idx--;
+    if (prev.role !== "model")
+      break;
+    const hasToolCall2 = prev.parts?.some((p2) => p2.functionCall !== void 0);
+    if (!hasToolCall2)
+      break;
+    trimmed2.splice(trimmed2.length - 2, 2);
+    trimmed_count++;
   }
-  return idx;
+  return trimmed2;
 }
-var COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, INCREMENTAL_PROTECTED_TAIL, INCREMENTAL_MAX_CHUNK_SIZE, COMPRESSED_CONTEXT_PREFIX, MIN_COMPRESSION_FRACTION, ChatCompressionService;
-var init_chatCompressionService = __esm({
-  "packages/core/dist/src/services/chatCompressionService.js"() {
+function isSchemaDepthError(errorMessage) {
+  return errorMessage.includes("maximum schema depth exceeded");
+}
+function isInvalidArgumentError(errorMessage) {
+  return errorMessage.includes("Request contains an invalid argument");
+}
+var debugLogger25, StreamEventType, INVALID_CONTENT_RETRY_OPTIONS, INVALID_STREAM_RETRY_CONFIG, RATE_LIMIT_RETRY_OPTIONS, TRUNCATION_CASCADE_MARKER, LARGE_TOOL_RESPONSE_TRIM_CHARS, InvalidStreamError, GeminiChat;
+var init_geminiChat = __esm({
+  "packages/core/dist/src/core/geminiChat.js"() {
     "use strict";
     init_esbuild_shims();
+    init_node();
+    init_retry();
+    init_errors();
+    init_debugLogger();
+    init_errorParsing();
+    init_rateLimit();
+    init_contextLengthError();
+    init_tools();
+    init_chatCompressionService();
     init_turn();
-    init_uiTelemetry();
-    init_tokenLimits();
-    init_prompts();
-    init_partUtils();
     init_loggers();
+    init_chatRecordingService();
     init_types4();
-    init_types6();
-    init_sessionNotes();
-    init_sessionMemoryUtils();
-    init_prompts2();
-    init_microcompact();
-    COMPRESSION_TOKEN_THRESHOLD = 0.7;
-    COMPRESSION_PRESERVE_THRESHOLD = 0.3;
-    INCREMENTAL_PROTECTED_TAIL = 10;
-    INCREMENTAL_MAX_CHUNK_SIZE = 20;
-    COMPRESSED_CONTEXT_PREFIX = "[COMPRESSED_CONTEXT]";
-    MIN_COMPRESSION_FRACTION = 0.05;
-    __name(applyObservationMask, "applyObservationMask");
-    __name(extractContentText, "extractContentText");
-    __name(isCompressedMessage, "isCompressedMessage");
-    __name(findCompressSplitPoint, "findCompressSplitPoint");
-    ChatCompressionService = class {
+    debugLogger25 = createDebugLogger("QWEN_CODE_CHAT");
+    (function(StreamEventType2) {
+      StreamEventType2["CHUNK"] = "chunk";
+      StreamEventType2["RETRY"] = "retry";
+    })(StreamEventType || (StreamEventType = {}));
+    INVALID_CONTENT_RETRY_OPTIONS = {
+      maxAttempts: 2,
+      // 1 initial call + 1 retry
+      initialDelayMs: 500
+    };
+    INVALID_STREAM_RETRY_CONFIG = {
+      maxRetries: 2,
+      initialDelayMs: 2e3
+    };
+    RATE_LIMIT_RETRY_OPTIONS = {
+      maxRetries: 10,
+      delayMs: 6e4
+    };
+    __name(isValidResponse2, "isValidResponse");
+    __name(isValidNonThoughtTextPart, "isValidNonThoughtTextPart");
+    __name(isValidContent2, "isValidContent");
+    __name(isValidContentPart, "isValidContentPart");
+    __name(validateHistory2, "validateHistory");
+    __name(extractCuratedHistory2, "extractCuratedHistory");
+    TRUNCATION_CASCADE_MARKER = "truncated due to max_tokens limit";
+    LARGE_TOOL_RESPONSE_TRIM_CHARS = 1e4;
+    __name(hasTruncationCascade, "hasTruncationCascade");
+    __name(trimLargeToolResponsesFromContext, "trimLargeToolResponsesFromContext");
+    __name(trimToolErrorsFromContext, "trimToolErrorsFromContext");
+    InvalidStreamError = class extends Error {
       static {
-        __name(this, "ChatCompressionService");
+        __name(this, "InvalidStreamError");
       }
-      async compress(chat, promptId, force, model, config2, hasFailedCompressionAttempt, signal) {
-        const curatedHistory = chat.getHistory(true);
-        const threshold = config2.getChatCompression()?.contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
-        if (curatedHistory.length === 0 || threshold <= 0 || hasFailedCompressionAttempt && !force) {
-          return {
-            newHistory: null,
-            info: {
-              originalTokenCount: 0,
-              newTokenCount: 0,
-              compressionStatus: CompressionStatus.NOOP
-            }
-          };
-        }
-        const originalTokenCount = uiTelemetryService.getLastPromptTokenCount();
-        if (!force) {
-          const contextLimit = config2.getContentGeneratorConfig()?.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
-          if (originalTokenCount < threshold * contextLimit) {
-            return {
-              newHistory: null,
-              info: {
-                originalTokenCount,
-                newTokenCount: originalTokenCount,
-                compressionStatus: CompressionStatus.NOOP
-              }
-            };
-          }
-        }
-        if (!force) {
-          const smResult = await this.trySessionMemoryCompaction(curatedHistory, originalTokenCount, config2);
-          if (smResult)
-            return smResult;
-        }
-        if (!force) {
-          const saving = estimateMicrocompactSaving(curatedHistory);
-          if (saving >= 0.2) {
-            const { newHistory: microHistory } = applyMicrocompact(curatedHistory);
-            const newTokenCount = Math.round(originalTokenCount * (1 - saving));
-            uiTelemetryService.setLastPromptTokenCount(newTokenCount);
-            return {
-              newHistory: microHistory,
-              info: {
-                originalTokenCount,
-                newTokenCount,
-                compressionStatus: CompressionStatus.COMPRESSED
-              }
-            };
-          }
-        }
-        const hookSystem = config2.getHookSystem();
-        if (hookSystem) {
-          const trigger = force ? PreCompactTrigger.Manual : PreCompactTrigger.Auto;
-          try {
-            await hookSystem.firePreCompactEvent(trigger, "", signal);
-          } catch (err3) {
-            config2.getDebugLogger().warn(`PreCompact hook failed: ${err3}`);
-          }
-        }
-        const incrementalResult = await this.compressIncremental(curatedHistory, model, config2, promptId, signal);
-        if (incrementalResult.compressed) {
-          return this.finalizeCompression(incrementalResult.newHistory, originalTokenCount, incrementalResult.compressionInputTokenCount, incrementalResult.compressionOutputTokenCount, model, config2, signal);
-        }
-        return this.compressFull(curatedHistory, originalTokenCount, model, config2, promptId, force, signal);
+      type;
+      constructor(message, type) {
+        super(message);
+        this.name = "InvalidStreamError";
+        this.type = type;
+      }
+    };
+    GeminiChat = class {
+      static {
+        __name(this, "GeminiChat");
       }
+      config;
+      generationConfig;
+      history;
+      chatRecordingService;
+      telemetryService;
+      // A promise to represent the current state of the message being sent to the
+      // model.
+      sendPromise = Promise.resolve();
       /**
-       * Incremental compression: protects the most recent messages and compresses
-       * the oldest uncompressed chunk. Each call compresses one chunk, making the
-       * operation idempotent and safe to call repeatedly.
+       * Creates a new GeminiChat instance.
+       *
+       * @param config - The configuration object.
+       * @param generationConfig - Optional generation configuration.
+       * @param history - Optional initial conversation history.
+       * @param chatRecordingService - Optional recording service. If provided, chat
+       *   messages will be recorded.
+       * @param telemetryService - Optional UI telemetry service. When provided,
+       *   prompt token counts are reported on each API response. Pass `undefined`
+       *   for sub-agent chats to avoid overwriting the main agent's context usage.
        */
-      async compressIncremental(history, model, config2, promptId, _signal) {
-        const protectedTailMessages = INCREMENTAL_PROTECTED_TAIL;
-        const maxChunkSize = INCREMENTAL_MAX_CHUNK_SIZE;
-        if (history.length <= protectedTailMessages + 2) {
-          return { newHistory: history, compressed: false };
-        }
-        const compressibleEnd = history.length - protectedTailMessages;
-        let chunkStart = 0;
-        while (chunkStart < compressibleEnd) {
-          if (isCompressedMessage(history[chunkStart])) {
-            chunkStart++;
-          } else {
-            break;
-          }
-        }
-        if (chunkStart >= compressibleEnd) {
-          return { newHistory: history, compressed: false };
+      constructor(config2, generationConfig = {}, history = [], chatRecordingService, telemetryService) {
+        this.config = config2;
+        this.generationConfig = generationConfig;
+        this.history = history;
+        this.chatRecordingService = chatRecordingService;
+        this.telemetryService = telemetryService;
+        validateHistory2(history);
+      }
+      setSystemInstruction(sysInstr) {
+        this.generationConfig.systemInstruction = sysInstr;
+      }
+      /**
+       * Sends a message to the model and returns the response in chunks.
+       *
+       * @remarks
+       * This method will wait for the previous message to be processed before
+       * sending the next message.
+       *
+       * @see {@link Chat#sendMessage} for non-streaming method.
+       * @param params - parameters for sending the message.
+       * @return The model's response.
+       *
+       * @example
+       * ```ts
+       * const chat = ai.chats.create({model: 'gemini-2.0-flash'});
+       * const response = await chat.sendMessageStream({
+       * message: 'Why is the sky blue?'
+       * });
+       * for await (const chunk of response) {
+       * console.log(chunk.text);
+       * }
+       * ```
+       */
+      async sendMessageStream(model, params, prompt_id) {
+        await this.sendPromise;
+        let streamDoneResolver;
+        const streamDonePromise = new Promise((resolve37) => {
+          streamDoneResolver = resolve37;
+        });
+        this.sendPromise = streamDonePromise;
+        const userContent = createUserContent(params.message);
+        this.history.push(userContent);
+        let requestContents = this.getHistory(true);
+        if (hasTruncationCascade(requestContents)) {
+          const withoutErrors = trimToolErrorsFromContext(requestContents);
+          requestContents = trimLargeToolResponsesFromContext(withoutErrors);
+          debugLogger25.warn(`MAX_TOKENS cascade detected: trimmed context from ${this.getHistory(true).length} to ${requestContents.length} entries and capped large tool responses.`);
         }
-        const chunkEnd = Math.min(chunkStart + maxChunkSize, compressibleEnd);
-        const chunk = history.slice(chunkStart, chunkEnd);
-        const summaryResponse = await config2.getContentGenerator().generateContent({
-          model,
-          contents: [
-            ...chunk,
-            {
-              role: "user",
-              parts: [
-                {
-                  text: "Compress the conversation chunk above into a dense summary following the output format."
+        const self2 = this;
+        return async function* () {
+          try {
+            let lastError = new Error("Request failed after all retries.");
+            let rateLimitRetryCount = 0;
+            let invalidStreamRetryCount = 0;
+            let reactiveCompressionAttempted = false;
+            const cgConfig = self2.config.getContentGeneratorConfig();
+            const maxRateLimitRetries = cgConfig?.maxRetries ?? RATE_LIMIT_RETRY_OPTIONS.maxRetries;
+            const extraRetryErrorCodes = cgConfig?.retryErrorCodes;
+            for (let attempt = 0; attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
+              try {
+                if (attempt > 0 || rateLimitRetryCount > 0 || invalidStreamRetryCount > 0) {
+                  yield { type: StreamEventType.RETRY };
                 }
-              ]
+                const stream2 = await self2.makeApiCallAndProcessStream(model, requestContents, params, prompt_id);
+                for await (const chunk of stream2) {
+                  yield { type: StreamEventType.CHUNK, value: chunk };
+                }
+                lastError = null;
+                break;
+              } catch (error40) {
+                lastError = error40;
+                const isRateLimit = isRateLimitError(error40, extraRetryErrorCodes);
+                if (isRateLimit && rateLimitRetryCount < maxRateLimitRetries) {
+                  rateLimitRetryCount++;
+                  const delayMs = RATE_LIMIT_RETRY_OPTIONS.delayMs;
+                  const message = parseAndFormatApiError(error40 instanceof Error ? error40.message : String(error40));
+                  debugLogger25.warn(`Rate limit throttling detected (retry ${rateLimitRetryCount}/${maxRateLimitRetries}). Waiting ${delayMs / 1e3}s before retrying...`);
+                  yield {
+                    type: StreamEventType.RETRY,
+                    retryInfo: {
+                      message,
+                      attempt: rateLimitRetryCount,
+                      maxRetries: maxRateLimitRetries,
+                      delayMs
+                    }
+                  };
+                  attempt--;
+                  await new Promise((res) => setTimeout(res, delayMs));
+                  continue;
+                }
+                const isTransientStreamError = error40 instanceof InvalidStreamError;
+                if (isTransientStreamError && invalidStreamRetryCount < INVALID_STREAM_RETRY_CONFIG.maxRetries) {
+                  invalidStreamRetryCount++;
+                  const delayMs = INVALID_STREAM_RETRY_CONFIG.initialDelayMs * invalidStreamRetryCount;
+                  debugLogger25.warn(`Invalid stream [${error40.type}] (retry ${invalidStreamRetryCount}/${INVALID_STREAM_RETRY_CONFIG.maxRetries}). Waiting ${delayMs / 1e3}s before retrying...`);
+                  logContentRetry(self2.config, new ContentRetryEvent(invalidStreamRetryCount - 1, error40.type, delayMs, model));
+                  yield { type: StreamEventType.RETRY };
+                  attempt--;
+                  await new Promise((res) => setTimeout(res, delayMs));
+                  continue;
+                }
+                if (isTransientStreamError && error40.type === "NO_RESPONSE_TEXT") {
+                  const trimmedContents = trimToolErrorsFromContext(requestContents);
+                  if (trimmedContents.length < requestContents.length) {
+                    debugLogger25.warn(`NO_RESPONSE_TEXT: retrying with trimmed context (removed ${requestContents.length - trimmedContents.length} tool-error messages)`);
+                    try {
+                      const stream2 = await self2.makeApiCallAndProcessStream(model, trimmedContents, params, prompt_id);
+                      for await (const chunk of stream2) {
+                        yield { type: StreamEventType.CHUNK, value: chunk };
+                      }
+                      lastError = null;
+                    } catch {
+                    }
+                  }
+                  break;
+                }
+                if (isTransientStreamError) {
+                  break;
+                }
+                if (!reactiveCompressionAttempted) {
+                  const overflow = getContextLengthExceededInfo(error40);
+                  if (overflow.isExceeded) {
+                    reactiveCompressionAttempted = true;
+                    debugLogger25.warn("Context length exceeded; attempting reactive compression and one retry.");
+                    try {
+                      const { newHistory, info: info3 } = await new ChatCompressionService().compress(
+                        self2,
+                        prompt_id,
+                        true,
+                        // force — bypasses the hasFailedCompressionAttempt guard
+                        model,
+                        self2.config,
+                        false,
+                        params.config?.abortSignal
+                      );
+                      if (info3.compressionStatus === CompressionStatus.COMPRESSED && newHistory) {
+                        self2.setHistory(newHistory);
+                        self2.config.getFileReadCache().clear();
+                        self2.telemetryService?.setLastPromptTokenCount(info3.newTokenCount);
+                        requestContents = self2.getHistory(true);
+                        debugLogger25.info(`Reactive compression succeeded (${info3.originalTokenCount} -> ${info3.newTokenCount} tokens); retrying.`);
+                        attempt--;
+                        yield { type: StreamEventType.RETRY };
+                        continue;
+                      }
+                      debugLogger25.warn("Reactive compression did not reduce context; giving up.");
+                    } catch (compressionError) {
+                      debugLogger25.warn(`Reactive compression failed: ${compressionError instanceof Error ? compressionError.message : String(compressionError)}`);
+                    }
+                    break;
+                  }
+                }
+                const isContentError = error40 instanceof InvalidStreamError;
+                if (isContentError) {
+                  if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
+                    logContentRetry(self2.config, new ContentRetryEvent(attempt, error40.type, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs, model));
+                    await new Promise((res) => setTimeout(res, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs * (attempt + 1)));
+                    continue;
+                  }
+                }
+                break;
+              }
             }
-          ],
-          config: {
-            systemInstruction: getIncrementalCompressionPrompt()
+            if (lastError) {
+              if (lastError instanceof InvalidStreamError) {
+                const totalAttempts = invalidStreamRetryCount + 1;
+                logContentRetryFailure(self2.config, new ContentRetryFailureEvent(totalAttempts, lastError.type, model));
+              }
+              throw lastError;
+            }
+          } finally {
+            streamDoneResolver();
           }
-        }, promptId);
-        const summary = getResponseText(summaryResponse) ?? "";
-        if (!summary || summary.trim().length === 0) {
-          return { newHistory: history, compressed: false };
-        }
-        const prefixedSummary = summary.startsWith(COMPRESSED_CONTEXT_PREFIX) ? summary : `${COMPRESSED_CONTEXT_PREFIX}
-${summary}`;
-        const usageMetadata = summaryResponse.usageMetadata;
-        const inputTokenCount = usageMetadata?.promptTokenCount;
-        let outputTokenCount = usageMetadata?.candidatesTokenCount;
-        if (outputTokenCount === void 0 && typeof usageMetadata?.totalTokenCount === "number" && typeof inputTokenCount === "number") {
-          outputTokenCount = Math.max(0, usageMetadata.totalTokenCount - inputTokenCount);
-        }
-        const summaryMessage = {
-          role: "user",
-          parts: [{ text: prefixedSummary }]
-        };
-        const summaryAck = {
-          role: "model",
-          parts: [{ text: "Understood. Incremental context loaded." }]
-        };
-        const newHistory = [
-          ...history.slice(0, chunkStart),
-          summaryMessage,
-          summaryAck,
-          ...history.slice(chunkEnd)
-        ];
-        return {
-          newHistory,
-          compressed: true,
-          compressionInputTokenCount: inputTokenCount,
-          compressionOutputTokenCount: outputTokenCount
-        };
+        }();
+      }
+      async makeApiCallAndProcessStream(model, requestContents, params, prompt_id) {
+        const apiCall = /* @__PURE__ */ __name(() => this.config.getContentGenerator().generateContentStream({
+          model,
+          contents: requestContents,
+          config: { ...this.generationConfig, ...params.config }
+        }, prompt_id), "apiCall");
+        const streamResponse2 = await retryWithBackoff(apiCall, {
+          shouldRetryOnError: /* @__PURE__ */ __name((error40) => {
+            if (error40 instanceof Error) {
+              if (isSchemaDepthError(error40.message))
+                return false;
+              if (isInvalidArgumentError(error40.message))
+                return false;
+            }
+            const status = getErrorStatus(error40);
+            if (status === 400)
+              return false;
+            if (status === 429)
+              return true;
+            if (status && status >= 500 && status < 600)
+              return true;
+            return false;
+          }, "shouldRetryOnError")
+        });
+        return this.processStreamResponse(model, streamResponse2);
       }
       /**
-       * Original full-history compression using getCompressionPrompt().
-       * Used as a fallback when history is too short for incremental compression.
+       * Returns the chat history.
+       *
+       * @remarks
+       * The history is a list of contents alternating between user and model.
+       *
+       * There are two types of history:
+       * - The `curated history` contains only the valid turns between user and
+       * model, which will be included in the subsequent requests sent to the model.
+       * - The `comprehensive history` contains all turns, including invalid or
+       * empty model outputs, providing a complete record of the history.
+       *
+       * The history is updated after receiving the response from the model,
+       * for streaming response, it means receiving the last chunk of the response.
+       *
+       * The `comprehensive history` is returned by default. To get the `curated
+       * history`, set the `curated` parameter to `true`.
+       *
+       * @param curated - whether to return the curated history or the comprehensive
+       * history.
+       * @return History contents alternating between user and model for the entire
+       * chat session.
        */
-      async compressFull(curatedHistory, originalTokenCount, model, config2, promptId, force, signal) {
-        const lastMessage = curatedHistory[curatedHistory.length - 1];
-        const hasOrphanedFuncCall = force && lastMessage?.role === "model" && lastMessage.parts?.some((p2) => !!p2.functionCall);
-        const historyForSplit = hasOrphanedFuncCall ? curatedHistory.slice(0, -1) : curatedHistory;
-        const splitPoint = findCompressSplitPoint(historyForSplit, 1 - COMPRESSION_PRESERVE_THRESHOLD);
-        const historyToCompress = historyForSplit.slice(0, splitPoint);
-        const historyToKeep = historyForSplit.slice(splitPoint);
-        if (historyToCompress.length === 0) {
-          return {
-            newHistory: null,
-            info: {
-              originalTokenCount,
-              newTokenCount: originalTokenCount,
-              compressionStatus: CompressionStatus.NOOP
+      getHistory(curated = false) {
+        const history = curated ? extractCuratedHistory2(this.history) : this.history;
+        return structuredClone(history);
+      }
+      /**
+       * Clears the chat history.
+       */
+      clearHistory() {
+        this.history = [];
+      }
+      /**
+       * Adds a new entry to the chat history.
+       */
+      addHistory(content) {
+        this.history.push(content);
+      }
+      setHistory(history) {
+        this.history = history;
+      }
+      stripThoughtsFromHistory() {
+        this.history = this.history.map((content) => {
+          if (!content.parts)
+            return content;
+          const filteredParts = content.parts.filter((part) => !(part && typeof part === "object" && "thought" in part && part.thought)).map((part) => {
+            if (part && typeof part === "object" && "thoughtSignature" in part) {
+              const newPart = { ...part };
+              delete newPart.thoughtSignature;
+              return newPart;
             }
-          };
-        }
-        const compressCharCount = historyToCompress.reduce((sum, c4) => sum + JSON.stringify(c4).length, 0);
-        const totalCharCount = historyForSplit.reduce((sum, c4) => sum + JSON.stringify(c4).length, 0);
-        if (totalCharCount > 0 && compressCharCount / totalCharCount < MIN_COMPRESSION_FRACTION) {
+            return part;
+          });
           return {
-            newHistory: null,
-            info: {
-              originalTokenCount,
-              newTokenCount: originalTokenCount,
-              compressionStatus: CompressionStatus.NOOP
-            }
+            ...content,
+            parts: filteredParts
           };
-        }
-        const summaryResponse = await config2.getContentGenerator().generateContent({
-          model,
-          contents: [
-            ...historyToCompress,
-            {
-              role: "user",
-              parts: [
-                {
-                  text: "Generate the <summary> now. Be maximally concise \u2014 every token counts."
-                }
-              ]
-            }
-          ],
-          config: {
-            systemInstruction: getCompressionPrompt()
-          }
-        }, promptId);
-        const summary = getResponseText(summaryResponse) ?? "";
-        const prefixedSummary = summary && summary.trim().length > 0 ? summary.startsWith(COMPRESSED_CONTEXT_PREFIX) ? summary : `${COMPRESSED_CONTEXT_PREFIX}
-${summary}` : summary;
-        const compressionUsageMetadata = summaryResponse.usageMetadata;
-        const compressionInputTokenCount = compressionUsageMetadata?.promptTokenCount;
-        let compressionOutputTokenCount = compressionUsageMetadata?.candidatesTokenCount;
-        if (compressionOutputTokenCount === void 0 && typeof compressionUsageMetadata?.totalTokenCount === "number" && typeof compressionInputTokenCount === "number") {
-          compressionOutputTokenCount = Math.max(0, compressionUsageMetadata.totalTokenCount - compressionInputTokenCount);
-        }
-        const isSummaryEmpty = !prefixedSummary || prefixedSummary.trim().length === 0;
-        let extraHistory = [];
-        if (!isSummaryEmpty) {
-          extraHistory = [
-            {
-              role: "user",
-              parts: [{ text: prefixedSummary }]
-            },
-            {
-              role: "model",
-              parts: [{ text: "Got it. Thanks for the additional context!" }]
-            },
-            ...historyToKeep
-          ];
-        }
-        return this.finalizeCompression(isSummaryEmpty ? null : extraHistory, originalTokenCount, compressionInputTokenCount, compressionOutputTokenCount, model, config2, signal, isSummaryEmpty);
+        }).filter((content) => content.parts && content.parts.length > 0);
       }
       /**
-       * Shared finalization logic for both incremental and full compression.
-       * Handles token math, telemetry, hook firing, and status determination.
+       * Pop all orphaned trailing user entries from chat history.
+       * In a valid conversation the last entry is always a model response;
+       * any trailing user entries are leftovers from a request that failed.
        */
-      async finalizeCompression(newHistory, originalTokenCount, compressionInputTokenCount, compressionOutputTokenCount, model, config2, signal, isSummaryEmpty = false) {
-        let newTokenCount = originalTokenCount;
-        let canCalculateNewTokenCount = false;
-        if (!isSummaryEmpty && newHistory) {
-          if (typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
-            canCalculateNewTokenCount = true;
-            newTokenCount = Math.max(0, originalTokenCount - (compressionInputTokenCount - 1e3) + compressionOutputTokenCount);
+      stripOrphanedUserEntriesFromHistory() {
+        while (this.history.length > 0 && this.history[this.history.length - 1].role === "user") {
+          this.history.pop();
+        }
+      }
+      setTools(tools) {
+        this.generationConfig.tools = tools;
+      }
+      /** Returns a shallow copy of the current generation config (for cache param snapshots). */
+      getGenerationConfig() {
+        return { ...this.generationConfig };
+      }
+      async maybeIncludeSchemaDepthContext(error40) {
+        if (isSchemaDepthError(error40.message) || isInvalidArgumentError(error40.message)) {
+          const tools = this.config.getToolRegistry().getAllTools();
+          const cyclicSchemaTools = [];
+          for (const tool of tools) {
+            if (tool.schema.parametersJsonSchema && hasCycleInSchema(tool.schema.parametersJsonSchema) || tool.schema.parameters && hasCycleInSchema(tool.schema.parameters)) {
+              cyclicSchemaTools.push(tool.displayName);
+            }
+          }
+          if (cyclicSchemaTools.length > 0) {
+            const extraDetails = `
+
+This error was probably caused by cyclic schema references in one of the following tools, try disabling them with excludeTools:
+
+ - ` + cyclicSchemaTools.join(`
+ - `) + `
+`;
+            error40.message += extraDetails;
           }
         }
-        logChatCompression(config2, makeChatCompressionEvent({
-          tokens_before: originalTokenCount,
-          tokens_after: newTokenCount,
-          compression_input_token_count: compressionInputTokenCount,
-          compression_output_token_count: compressionOutputTokenCount
-        }));
-        if (isSummaryEmpty) {
-          return {
-            newHistory: null,
-            info: {
-              originalTokenCount,
-              newTokenCount: originalTokenCount,
-              compressionStatus: CompressionStatus.COMPRESSION_FAILED_EMPTY_SUMMARY
+      }
+      async *processStreamResponse(model, streamResponse2) {
+        const allModelParts = [];
+        let usageMetadata;
+        let hasToolCall2 = false;
+        let hasFinishReason = false;
+        for await (const chunk of streamResponse2) {
+          hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
+          if (isValidResponse2(chunk)) {
+            const content = chunk.candidates?.[0]?.content;
+            if (content?.parts) {
+              if (content.parts.some((part) => part.functionCall)) {
+                hasToolCall2 = true;
+              }
+              allModelParts.push(...content.parts);
             }
-          };
-        } else if (!canCalculateNewTokenCount) {
-          return {
-            newHistory: null,
-            info: {
-              originalTokenCount,
-              newTokenCount: originalTokenCount,
-              compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR
+          }
+          if (chunk.usageMetadata) {
+            usageMetadata = chunk.usageMetadata;
+            const lastPromptTokenCount = usageMetadata.totalTokenCount || usageMetadata.promptTokenCount;
+            if (lastPromptTokenCount && this.telemetryService) {
+              this.telemetryService.setLastPromptTokenCount(lastPromptTokenCount);
             }
-          };
-        } else if (newTokenCount > originalTokenCount) {
-          return {
-            newHistory: null,
-            info: {
-              originalTokenCount,
-              newTokenCount,
-              compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT
+            if (usageMetadata.cachedContentTokenCount && this.telemetryService) {
+              this.telemetryService.setLastCachedContentTokenCount(usageMetadata.cachedContentTokenCount);
             }
-          };
-        } else {
-          uiTelemetryService.setLastPromptTokenCount(newTokenCount);
-          try {
-            const permissionMode = String(config2.getApprovalMode());
-            await config2.getHookSystem()?.fireSessionStartEvent(SessionStartSource.Compact, model ?? "", permissionMode, void 0, signal);
-          } catch (err3) {
-            config2.getDebugLogger().warn(`SessionStart hook failed: ${err3}`);
           }
-          return {
-            newHistory,
-            info: {
-              originalTokenCount,
-              newTokenCount,
-              compressionStatus: CompressionStatus.COMPRESSED
-            }
+          yield chunk;
+        }
+        let thoughtContentPart;
+        const thoughtText = allModelParts.filter((part) => part.thought).map((part) => part.text).join("").trim();
+        if (thoughtText !== "") {
+          thoughtContentPart = {
+            text: thoughtText,
+            thought: true
           };
+          const thoughtSignature = allModelParts.filter((part) => part.thoughtSignature && part.thought)?.[0]?.thoughtSignature;
+          if (thoughtContentPart && thoughtSignature) {
+            thoughtContentPart.thoughtSignature = thoughtSignature;
+          }
         }
-      }
-      // ---------------------------------------------------------------------------
-      // Session Memory fast-path compaction
-      // ---------------------------------------------------------------------------
-      /**
-       * Attempt to compact using the continuously-maintained session notes file
-       * instead of making a fresh LLM summarisation call.
-       *
-       * Returns null when the notes are absent, empty, or would not meaningfully
-       * reduce the context (≥ 90 % of original tokens), causing the caller to fall
-       * through to the normal LLM compression pipeline.
-       */
-      async trySessionMemoryCompaction(history, originalTokenCount, config2) {
-        try {
-          await waitForExtraction();
-          const projectDir = config2.getProjectRoot();
-          const notes = await readSessionNotes(projectDir);
-          if (!notes || isSessionNotesEmpty(notes))
-            return null;
-          const { truncated, wasTruncated } = truncateNotesForCompact(notes);
-          const summaryText = `[SESSION_MEMORY_SUMMARY]
-The following is a running summary of this conversation maintained by the session memory agent.
-` + (wasTruncated ? `(Some sections were truncated for length. Full notes at ${config2.getProjectRoot()}/.proto/session-notes.md)
-` : "") + `
-${truncated}`;
-          const MIN_PRESERVED_TOKENS = 1e4;
-          const lastSummarized = getLastSummarizedCursorIndex();
-          let keepFromIndex = lastSummarized >= 0 ? lastSummarized + 1 : history.length;
-          let preservedTokens = estimateHistoryTokens(history.slice(keepFromIndex));
-          while (keepFromIndex > 0 && preservedTokens < MIN_PRESERVED_TOKENS) {
-            keepFromIndex--;
-            preservedTokens += estimateHistoryTokens([history[keepFromIndex]]);
+        const contentParts = allModelParts.filter((part) => !part.thought);
+        const consolidatedHistoryParts = [];
+        for (const part of contentParts) {
+          const lastPart = consolidatedHistoryParts[consolidatedHistoryParts.length - 1];
+          if (lastPart?.text && isValidNonThoughtTextPart(lastPart) && isValidNonThoughtTextPart(part)) {
+            lastPart.text += part.text;
+          } else if (isValidContentPart(part)) {
+            consolidatedHistoryParts.push(part);
+          }
+        }
+        const contentText = consolidatedHistoryParts.filter((part) => part.text).map((part) => part.text).join("").trim();
+        if (thoughtContentPart || contentText || hasToolCall2 || usageMetadata) {
+          const contextWindowSize = this.config.getContentGeneratorConfig()?.contextWindowSize;
+          this.chatRecordingService?.recordAssistantTurn({
+            model,
+            message: [
+              ...thoughtContentPart ? [thoughtContentPart] : [],
+              ...contentText ? [{ text: contentText }] : [],
+              ...hasToolCall2 ? contentParts.filter((part) => part.functionCall).map((part) => ({ functionCall: part.functionCall })) : []
+            ],
+            tokens: usageMetadata,
+            contextWindowSize
+          });
+        }
+        if (!hasToolCall2 && (!hasFinishReason || !contentText)) {
+          if (!hasFinishReason) {
+            throw new InvalidStreamError("Model stream ended without a finish reason.", "NO_FINISH_REASON");
+          } else {
+            throw new InvalidStreamError("Model stream ended with empty response text.", "NO_RESPONSE_TEXT");
           }
-          keepFromIndex = adjustIndexForToolPairs(history, keepFromIndex);
-          const preservedTail = history.slice(keepFromIndex);
-          const summaryUserMsg = {
-            role: "user",
-            parts: [{ text: summaryText }]
-          };
-          const summaryAckMsg = {
-            role: "model",
-            parts: [
-              {
-                text: "Understood. I have the session summary and will continue from the current state."
-              }
-            ]
-          };
-          const newHistory = [summaryUserMsg, summaryAckMsg, ...preservedTail];
-          const newTokenCount = estimateHistoryTokens(newHistory);
-          if (newTokenCount >= originalTokenCount * 0.9)
-            return null;
-          return {
-            newHistory,
-            info: {
-              originalTokenCount,
-              newTokenCount,
-              compressionStatus: CompressionStatus.COMPRESSED
-            }
-          };
-        } catch {
-          return null;
         }
+        this.history.push({
+          role: "model",
+          parts: [
+            ...thoughtContentPart ? [thoughtContentPart] : [],
+            ...consolidatedHistoryParts
+          ]
+        });
       }
     };
-    __name(estimateHistoryTokens, "estimateHistoryTokens");
-    __name(adjustIndexForToolPairs, "adjustIndexForToolPairs");
+    __name(isSchemaDepthError, "isSchemaDepthError");
+    __name(isInvalidArgumentError, "isInvalidArgumentError");
+  }
+});
+
+// packages/core/dist/src/backgroundShells/notifications.js
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildBackgroundTaskNotification(task) {
+  const exitLine = task.exitCode !== void 0 && task.exitCode !== null ? `
+<exit_code>${task.exitCode}</exit_code>` : "";
+  const summary = (() => {
+    const desc2 = task.description || task.command;
+    switch (task.status) {
+      case "completed":
+        return `Background command "${desc2}" completed${task.exitCode != null ? ` (exit code ${task.exitCode})` : ""}.`;
+      case "failed":
+        return `Background command "${desc2}" failed${task.exitCode != null ? ` with exit code ${task.exitCode}` : ""}.`;
+      case "killed":
+        return `Background command "${desc2}" was stopped.`;
+      default:
+        return `Background command "${desc2}" ended in unknown state.`;
+    }
+  })();
+  return [
+    "<task_notification>",
+    `<task_id>${task.id}</task_id>`,
+    `<output_file>${task.outputPath}</output_file>`,
+    `<status>${task.status}</status>${exitLine}`,
+    `<summary>${escapeXml(summary)}</summary>`,
+    "</task_notification>",
+    "",
+    `Read ${task.outputPath} to see the full output.`
+  ].join("\n");
+}
+var init_notifications = __esm({
+  "packages/core/dist/src/backgroundShells/notifications.js"() {
+    "use strict";
+    init_esbuild_shims();
+    __name(escapeXml, "escapeXml");
+    __name(buildBackgroundTaskNotification, "buildBackgroundTaskNotification");
   }
 });
 
@@ -416607,7 +416785,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.51.2";
+  return "0.52.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -424807,7 +424985,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "a6b2897d3";
+var GIT_COMMIT_INFO = "0f21b967a";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -493609,7 +493787,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.51.2";
+    const version2 = "0.52.0";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -494696,11 +494874,8 @@ main().catch((error40) => {
  */
 /**
  * @license
- * Copyright 2025 protoLabs Studio
+ * Copyright 2026 protoCLI contributors
  * SPDX-License-Identifier: Apache-2.0
- *
- * Builds the <task_notification> blocks that get prepended to the next
- * user query so the model sees backgrounded tasks finishing.
  */
 /**
  * @license
@@ -494756,6 +494931,14 @@ main().catch((error40) => {
  * where result payloads are large but the call names / return structure
  * still provide useful signal to the model.
  */
+/**
+ * @license
+ * Copyright 2025 protoLabs Studio
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Builds the <task_notification> blocks that get prepended to the next
+ * user query so the model sees backgrounded tasks finishing.
+ */
 /**
  * @license
  * Copyright 2025 protoLabs Studio
@@ -494824,11 +495007,6 @@ main().catch((error40) => {
  * By constructing the forked GeminiChat with identical generationConfig and
  * history prefix, the fork automatically benefits from prefix caching.
  */
-/**
- * @license
- * Copyright 2026 protoCLI contributors
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2025 protoLabs Studio