@exulu/backend 2.0.1 → 2.1.0

package/dist/index.js

@@ -7,6 +7,9 @@ import {
   validatePythonEnvironment
 } from "./chunk-T6JVFT7L.js";
 import {
+  COMPACTION_INSUFFICIENT,
+  ContextCompactionRequiredError,
+  DEFAULT_CONTEXT_WINDOW,
   ExuluTool,
   LITELLM_UI_PATH,
   LiteLLMAdminError,
@@ -18,16 +21,19 @@ import {
   buildTags,
   checkLicense,
   checkRecordAccess,
+  contextOccupancy,
   convertExuluToolsToAiSdkTools,
   copyS3Object,
   createAgenticRetrievalTool,
-  createProjectItemsRetrievalTool,
   createTaggedFetch,
   createUppyRoutes,
   decryptOauthState,
   deleteS3Object,
+  deriveContextBudget,
   downloadKeyIntoSandbox,
   enableLiteLLMClientMode,
+  estimateMessageTokens,
+  estimateTokens,
   exchangeCodeForTokens,
   exuluApp,
   getBudgetSettings,
@@ -40,10 +46,12 @@ import {
   getTagDailyActivity,
   getToken,
   getUserBudgetView,
+  guardExtractedFileText,
   invalidateBudgetCaches,
   isLiteLLMEnabled,
   listS3ObjectsByPrefix,
   listTagsByPrefix,
+  mapStreamErrorMessage,
   oauthRegistry,
   oauthTokenStore,
   postgresClient,
@@ -55,15 +63,17 @@ import {
   sanitizeToolName,
   setBudgetSettings,
   setLiteLLMPackageRoot,
+  sliceHistoryAtCheckpoint,
   startLiteLLMSupervisor,
   tagDelete,
   tagInfo,
+  truncateToolOutput,
   updateStatistic,
   uploadFile,
   upsertBudget,
   waitForLiteLLMReady,
   withRetry
-} from "./chunk-IJ4HNHOT.js";
+} from "./chunk-RVZWZNWG.js";
 import {
   findLiteLLMModel
 } from "./chunk-7CCMW3IW.js";
@@ -2213,6 +2223,13 @@ var agentsSchema = {
       name: "sandbox_enabled",
       type: "boolean",
       default: false
+    },
+    {
+      // Per-turn budget for ALL tool steps on one chat message (bash, files,
+      // knowledge search, integrations). 0/null = platform default
+      // (DEFAULT_MAX_STEPS in resolve-max-steps.ts). Auto-ALTERed on boot.
+      name: "max_tool_steps",
+      type: "number"
     }
   ]
 };
@@ -4252,7 +4269,7 @@ var ExuluContext2 = class {
     embedder,
     chunker,
     processor,
-    active,
+    active: active2,
     fields,
     queryRewriter,
     resultReranker,
@@ -4283,7 +4300,7 @@ var ExuluContext2 = class {
     this.description = description;
     this.embedder = embedder;
     this.chunker = chunker;
-    this.active = active;
+    this.active = active2;
     this.queryRewriter = queryRewriter;
     this.resultReranker = resultReranker;
     this.entities = entities;
@@ -5398,14 +5415,26 @@ var addProviderFields = async (args, requestedFields, providers, result, tools,
         )
       );
       if (args.project) {
-        const projectTool = await createProjectItemsRetrievalTool({
-          projectId: args.project,
-          user,
-          role: user.role?.id,
-          contexts
-        });
-        if (projectTool) {
-          result.tools.unshift(projectTool);
+        const hasAgentic = result.tools.some(
+          (tool2) => tool2?.id === "agentic_context_search"
+        );
+        if (!hasAgentic) {
+          const instance = createAgenticRetrievalTool({
+            contexts: [],
+            user,
+            role: user.role?.id,
+            model: void 0
+          });
+          if (instance) {
+            result.tools.unshift({
+              id: instance.id,
+              name: instance.name,
+              description: instance.description,
+              category: instance.category,
+              type: instance.type,
+              config: []
+            });
+          }
         }
       }
       result.tools = result.tools.filter((tool2) => tool2 !== null);
@@ -11275,14 +11304,15 @@ import bodyParser from "body-parser";
 import CryptoJS4 from "crypto-js";
 import OpenAI from "openai";
 import fs2 from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import "@opentelemetry/api";
 import JSZip2 from "jszip";
 import { createIdGenerator } from "ai";
 import cookieParser from "cookie-parser";
 
 // src/exulu/resolve-max-steps.ts
-function resolveMaxStepsFromToolConfigs(toolConfigs) {
+var DEFAULT_MAX_STEPS = 10;
+function resolveRetrievalCallBudget(toolConfigs) {
   const agentic = toolConfigs?.find((t) => t.id === "agentic_context_search");
   if (!agentic?.config) return void 0;
   const entry = agentic.config.find((c) => c.name === "max_steps");
@@ -11291,15 +11321,26 @@ function resolveMaxStepsFromToolConfigs(toolConfigs) {
   const n = typeof raw === "number" ? raw : parseInt(String(raw ?? ""), 10);
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
 }
+function resolveTurnStepBudget(maxStepCount, agent) {
+  if (typeof maxStepCount === "number" && Number.isFinite(maxStepCount) && maxStepCount > 0) {
+    return Math.floor(maxStepCount);
+  }
+  const raw = agent?.max_tool_steps;
+  const n = typeof raw === "number" ? raw : parseInt(String(raw ?? ""), 10);
+  if (Number.isFinite(n) && n > 0) {
+    return Math.floor(n);
+  }
+  return DEFAULT_MAX_STEPS;
+}
 function flattenPart(part) {
   const p = part;
   if (p?.type === "text") return p.text ?? "";
   if (p?.type === "tool-call") {
-    return `[searched ${p.toolName}: ${JSON.stringify(p.input ?? {}).slice(0, 300)}]`;
+    return `Earlier, the assistant ran the "${p.toolName}" tool with input: ${JSON.stringify(p.input ?? {}).slice(0, 300)}`;
   }
   if (p?.type === "tool-result") {
     const out = p.output?.value ?? p.output;
-    return `[results from ${p.toolName}]: ${typeof out === "string" ? out : JSON.stringify(out ?? "")}`;
+    return `The "${p.toolName}" tool returned: ${typeof out === "string" ? out : JSON.stringify(out ?? "")}`;
   }
   return "";
 }
@@ -11317,7 +11358,7 @@ function flattenToolHistory(messages) {
     return m;
   });
 }
-var FINAL_ANSWER_INSTRUCTION = "Answer the user's original question now, in plain text, using only the material already retrieved above. Do not attempt any further tool calls.";
+var FINAL_ANSWER_INSTRUCTION = `This is your last step for this turn. Answer the user's original question now, in plain text, using only the information gathered above. If you could not finish the task, tell the user you reached the maximum number of tool steps, summarize what you found and did so far, and say what remains \u2014 they can ask you to continue. Do not attempt any further tool calls. Write your answer as normal prose for the user: do not output tool-call syntax, JSON commands, or bracketed lines such as "[called tool ...]" \u2014 describe anything you did or still plan to do in plain language.`;
 function finalAnswerGuard(maxSteps) {
   return ({ stepNumber, messages }) => stepNumber >= maxSteps - 1 ? {
     toolChoice: "none",
@@ -11330,6 +11371,68 @@ function finalAnswerGuard(maxSteps) {
     } : {}
   } : void 0;
 }
+function retrievalBudgetGuard(limit, agenticToolKey, allToolKeys) {
+  if (limit == null || limit <= 0 || !agenticToolKey || !allToolKeys.includes(agenticToolKey)) {
+    return () => void 0;
+  }
+  const remainingTools = allToolKeys.filter((k) => k !== agenticToolKey);
+  return ({ steps }) => {
+    const calls = (steps ?? []).flatMap((s) => s?.toolCalls ?? []).filter((c) => c?.toolName === agenticToolKey).length;
+    if (calls < limit) return void 0;
+    return { activeTools: remainingTools };
+  };
+}
+
+// src/exulu/context-guard.ts
+var KEEP_RECENT_TOOL_MESSAGES = 2;
+var COLLAPSE_KEEP_CHARS = 400;
+var COLLAPSE_MARKER = " \u2026[older tool output collapsed mid-response to fit the context window \u2014 the full output is in the session file named in the notice above, if one was saved]";
+function contextGuard(contextWindow) {
+  const budget = deriveContextBudget(contextWindow);
+  return async ({ messages }) => {
+    if (!Array.isArray(messages) || messages.length === 0) return void 0;
+    const tokens = estimateTokens(JSON.stringify(messages));
+    if (tokens < budget.usableWindow) return void 0;
+    const toolIndices = messages.map((m, i) => m?.role === "tool" ? i : -1).filter((i) => i !== -1);
+    const collapsible = new Set(toolIndices.slice(0, Math.max(0, toolIndices.length - KEEP_RECENT_TOOL_MESSAGES)));
+    if (collapsible.size === 0) return void 0;
+    let changed = false;
+    const next = messages.map((m, i) => {
+      if (!collapsible.has(i)) return m;
+      const msg = m;
+      if (!Array.isArray(msg.content)) return m;
+      const content = msg.content.map((part) => {
+        const p = part;
+        if (p?.type !== "tool-result") return part;
+        const out = p.output?.value ?? p.output;
+        const asText = typeof out === "string" ? out : JSON.stringify(out ?? "");
+        if (asText.length <= COLLAPSE_KEEP_CHARS + COLLAPSE_MARKER.length) return part;
+        changed = true;
+        return { ...part, output: { type: "text", value: asText.slice(0, COLLAPSE_KEEP_CHARS) + COLLAPSE_MARKER } };
+      });
+      return { ...m, content };
+    });
+    return changed ? { messages: next } : void 0;
+  };
+}
+function composePrepareSteps(...guards) {
+  return async (opts) => {
+    let merged;
+    let messages = opts.messages;
+    for (const guard of guards) {
+      const result = await guard({ ...opts, messages });
+      if (!result) continue;
+      merged = { ...merged ?? {}, ...result };
+      if (Array.isArray(result.messages)) {
+        messages = result.messages;
+      }
+    }
+    if (merged && messages && !("messages" in merged)) {
+      merged.messages = messages;
+    }
+    return merged;
+  };
+}
 
 // src/exulu/auto-decline-stale-approvals.ts
 var AUTO_DECLINE_REASON = "Automatically declined because the user sent a new message instead of responding to the approval request.";
@@ -11593,7 +11696,9 @@ var ExuluProvider = class {
     agent,
     instructions,
     maxStepCount,
-    onTokenUsage
+    onTokenUsage,
+    contextWindow,
+    disabledTools
   }) => {
     console.log(
       "[EXULU] Called generate sync for agent: " + this.name,
@@ -11621,9 +11726,7 @@ var ExuluProvider = class {
     if (messages && session && user) {
       const previousMessages = await getAgentMessages({
         session,
-        user: user.id,
-        limit: 50,
-        page: 1
+        user: user.id
       });
       const previousMessagesContent = previousMessages.map(
         (message) => JSON.parse(message.content)
@@ -11632,6 +11735,12 @@ var ExuluProvider = class {
         // append the new message to the previous messages:
         messages: [...previousMessagesContent, ...messages]
       });
+      const contextBudget = deriveContextBudget(contextWindow);
+      const occupancy = contextOccupancy(messages);
+      if (occupancy >= contextBudget.blockThreshold) {
+        throw new ContextCompactionRequiredError(occupancy, contextBudget);
+      }
+      messages = sliceHistoryAtCheckpoint(messages);
     }
     console.log(
       "[EXULU] Message count for agent: " + this.name,
@@ -11696,6 +11805,34 @@ var ExuluProvider = class {
     if (memoryContext) {
       system += "\n\n" + memoryContext;
     }
+    const tools = await convertExuluToolsToAiSdkTools(
+      currentTools,
+      currentSkills,
+      approvedTools,
+      allExuluTools,
+      toolConfigs,
+      providerapikey,
+      contexts,
+      user,
+      exuluConfig,
+      session,
+      req,
+      project,
+      sessionItems,
+      model,
+      agent,
+      memoryItems,
+      contextWindow,
+      disabledTools
+    );
+    const agenticEntry = currentTools?.find((t) => t.id === "agentic_context_search");
+    const agenticToolKey = agenticEntry ? sanitizeToolName(agenticEntry.name) : void 0;
+    const retrievalGuard = retrievalBudgetGuard(
+      resolveRetrievalCallBudget(toolConfigs),
+      agenticToolKey,
+      Object.keys(tools)
+    );
+    const turnBudget = resolveTurnStepBudget(maxStepCount, agent);
     const includesContextSearchTool = currentTools?.some(
       (tool2) => tool2.name.toLowerCase().includes("context_search") || tool2.id.includes("context_search") || tool2.type === "context"
     );
@@ -11708,12 +11845,12 @@ var ExuluProvider = class {
       system += `
 
 
-  
+
               When you use a context search tool, you will include references to the items
               retrieved from the tool call result inline in the response using this exact JSON format
               (all on one line, no line breaks):
               {item_name: <item_name>, item_id: <item_id>, context: <context_id>, chunk_id: <chunk_id>, chunk_index: <chunk_index>}
-  
+
               IMPORTANT formatting rules:
               - Do NOT reference just chunks like "Looking at chunk_index 5 and chunk_index 0 from the search result", always use the JSON format above.
               - Use the exact format shown above, all on ONE line
@@ -11721,9 +11858,9 @@ var ExuluProvider = class {
               - Use the context ID from the tool result
               - Include the file/item name, not the full path
               - Separate multiple citations with spaces
-  
+
               Example: {item_name: document.pdf, item_id: abc123, context: my-context-id, chunk_id: chunk_456, chunk_index: 0}
-  
+
               The citations will be rendered as interactive badges in the UI.
               `;
     }
@@ -11734,12 +11871,12 @@ var ExuluProvider = class {
               When you use a web search tool, you will include references to the results of the tool call result inline in the response using this exact JSON format
               (all on one line, no line breaks):
               {url: <url>, title: <title>, snippet: <snippet>}
-  
+
               IMPORTANT formatting rules:
               - Use the exact format shown above, all on ONE line
               - Do NOT use quotes around field names or values
               - Separate multiple results with spaces
-  
+
               Example: {url: https://www.google.com, title: Google, snippet: The result of the web search.}
               `;
     }
@@ -11772,29 +11909,12 @@ When a tool execution is not approved by the user, do not retry it unless explic
         system,
         prompt,
         maxRetries: 2,
-        tools: await convertExuluToolsToAiSdkTools(
-          currentTools,
-          currentSkills,
-          approvedTools,
-          allExuluTools,
-          toolConfigs,
-          providerapikey,
-          contexts,
-          user,
-          exuluConfig,
-          session,
-          req,
-          project,
-          sessionItems,
-          model,
-          agent,
-          memoryItems
-        ),
+        tools,
         // Stop after the image_generation tool fires — the widget IS the
         // assistant's response, no follow-up text turn is wanted (same
         // reasoning as question_ask: the UI artifact is the message).
-        prepareStep: finalAnswerGuard(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? 5),
-        stopWhen: [stepCountIs(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? 5), hasToolCall("image_generation")]
+        prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget)),
+        stopWhen: [stepCountIs(turnBudget), hasToolCall("image_generation")]
       });
       console.log("[EXULU] Output: " + JSON.stringify(output, null, 2));
       const {
@@ -11855,26 +11975,9 @@ When a tool execution is not approved by the user, do not retry it unless explic
           ignoreIncompleteToolCalls: true
         }),
         maxRetries: 2,
-        tools: await convertExuluToolsToAiSdkTools(
-          currentTools,
-          currentSkills,
-          approvedTools,
-          allExuluTools,
-          toolConfigs,
-          providerapikey,
-          contexts,
-          user,
-          exuluConfig,
-          session,
-          req,
-          project,
-          sessionItems,
-          model,
-          agent,
-          memoryItems
-        ),
-        prepareStep: finalAnswerGuard(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? 5),
-        stopWhen: [stepCountIs(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? 5), hasToolCall("image_generation")]
+        tools,
+        prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget)),
+        stopWhen: [stepCountIs(turnBudget), hasToolCall("image_generation")]
       });
       if (statistics) {
         await Promise.all([
@@ -11926,7 +12029,7 @@ When a tool execution is not approved by the user, do not retry it unless explic
    * - Document files (PDF, DOCX, etc.) -> text parts with extracted content using officeparser
    * - Image files -> image parts (which ARE supported by Responses API)
    */
-  async processFilePartsInMessages(messages) {
+  async processFilePartsInMessages(messages, offloadCtx) {
     const processedMessages = await Promise.all(
       messages.map(async (message) => {
         if (message.role !== "user" || !Array.isArray(message.parts)) {
@@ -11971,10 +12074,11 @@ When a tool execution is not approved by the user, do not retry it unless explic
                 outputErrorToConsole: false,
                 newlineDelimiter: "\n"
               });
+              const guardedText = await guardExtractedFileText(filename, String(extractedText), offloadCtx);
               return {
                 type: "text",
                 text: `<file file name = "${filename}" >
-${extractedText} 
+${guardedText} 
  </file>`
               };
             } catch (error) {
@@ -11990,7 +12094,6 @@ ${extractedText}
           ...message,
           parts: processedParts
         };
-        console.log("[EXULU] Result: " + JSON.stringify(result, null, 2));
         return result;
       })
     );
@@ -12013,7 +12116,9 @@ ${extractedText}
     exuluConfig,
     instructions,
     req,
-    maxStepCount
+    maxStepCount,
+    contextWindow,
+    disabledTools
   }) => {
     if (!this.config) {
       console.error("[EXULU] Config is required for streaming.");
@@ -12034,9 +12139,7 @@ ${extractedText}
       console.log("[EXULU] loading previous messages from session: " + session);
       const previousMessages2 = await getAgentMessages({
         session,
-        user: user?.id,
-        limit: 50,
-        page: 1
+        user: user?.id
       });
       previousMessagesContent = previousMessages2.map((message2) => JSON.parse(message2.content));
     }
@@ -12099,60 +12202,28 @@ ${extractedText}
     if (declined.length && session && user) {
       await saveChat({ session, user: user.id, messages: declined });
     }
-    messages = await this.processFilePartsInMessages(messages);
+    messages = await this.processFilePartsInMessages(messages, {
+      contextWindow,
+      sessionID: session,
+      user,
+      exuluConfig
+    });
+    const chronologicalMessages = messages;
+    const contextBudget = deriveContextBudget(contextWindow);
+    const occupancy = contextOccupancy(chronologicalMessages);
+    if (occupancy >= contextBudget.blockThreshold) {
+      console.warn(
+        `[EXULU] Blocking request: occupancy ${occupancy} >= blockThreshold ${contextBudget.blockThreshold} (window ${contextBudget.contextWindow}).`
+      );
+      throw new ContextCompactionRequiredError(occupancy, contextBudget);
+    }
+    messages = sliceHistoryAtCheckpoint(chronologicalMessages);
     const genericContext = "IMPORTANT: \n\n The current date is " + (/* @__PURE__ */ new Date()).toLocaleDateString() + " and the current time is " + (/* @__PURE__ */ new Date()).toLocaleTimeString() + ". If the user does not explicitly provide the current date, for examle when saying ' this weekend', you should assume they are talking with the current date in mind as a reference.";
     let system = instructions || "You are a helpful assistant. When you use a tool to answer a question do not explicitly comment on the result of the tool call unless the user has explicitly you to do something with the result.";
     if (user?.personal_system_prompt?.trim()) {
       system += "\n\nUser preferences:\n" + user.personal_system_prompt.trim();
     }
     system += "\n\n" + genericContext;
-    const includesContextSearchTool = currentTools?.some(
-      (tool2) => tool2.name.toLowerCase().includes("context_search") || tool2.id.includes("context_search") || tool2.type === "context"
-    );
-    const includesWebSearchTool = currentTools?.some(
-      (tool2) => tool2.name.toLowerCase().includes("web_search") || tool2.id.includes("web_search") || tool2.type === "web_search"
-    );
-    console.log("[EXULU] Current tools: " + currentTools?.map((tool2) => tool2.name).join("\n"));
-    console.log("[EXULU] Includes context search tool: " + includesContextSearchTool);
-    console.log("[EXULU] Includes web search tool: " + includesWebSearchTool);
-    if (includesContextSearchTool) {
-      system += `
-
-
-  
-              When you use a context search tool, you will include references to the items
-              retrieved from the tool call result inline in the response using this exact JSON format
-              (all on one line, no line breaks):
-              {item_name: <item_name>, item_id: <item_id>, context: <context_id>, chunk_id: <chunk_id>, chunk_index: <chunk_index>}
-  
-              IMPORTANT formatting rules:
-              - Use the exact format shown above, all on ONE line
-              - Do NOT use quotes around field names or values
-              - Use the context ID from the tool result
-              - Include the file/item name, not the full path
-              - Separate multiple citations with spaces
-  
-              Example: {item_name: document.pdf, item_id: abc123, context: my-context-id, chunk_id: chunk_456, chunk_index: 0}
-  
-              The citations will be rendered as interactive badges in the UI.
-              `;
-    }
-    if (includesWebSearchTool) {
-      system += `
-
-
-              When you use a web search tool, you will include references to the results of the tool call result inline in the response using this exact JSON format
-              (all on one line, no line breaks):
-              {url: <url>, title: <title>, snippet: <snippet>}
-  
-              IMPORTANT formatting rules:
-              - Use the exact format shown above, all on ONE line
-              - Do NOT use quotes around field names or values
-              - Separate multiple results with spaces
-  
-              Example: {url: https://www.google.com, title: Google, snippet: The result of the web search.}
-              `;
-    }
     if (currentSkills?.length) {
       const skillsList = currentSkills.map((skill) => {
         const description = (skill.description ?? "").trim();
@@ -12207,6 +12278,11 @@ ${skillsList}
         read them with the readFile tool. Files you produce yourself (via writeFile or via shell
         commands like \`node create_doc.js\`) live in the same place. These files are scoped to
         this single session; they are NOT visible in other sessions, projects, or knowledge bases.
+
+        Note on large outputs: oversized tool outputs and large uploaded documents are automatically
+        truncated in the conversation; the FULL content is saved as a session file (named in the
+        truncation notice, e.g. tool-output-*.txt). Use the read_session_file tool with offset/limit
+        to page through it \u2014 do not ask the user to re-upload.
       `;
     system += `
 
@@ -12230,9 +12306,66 @@ When a tool execution is not approved by the user, do not retry it unless explic
       sessionItems,
       model,
       agent,
-      memoryItems
+      memoryItems,
+      contextWindow,
+      disabledTools
     );
     console.log("[EXULU] Converted tools", Object.keys(tools));
+    const includesContextSearchTool = currentTools?.some(
+      (tool2) => tool2.name.toLowerCase().includes("context_search") || tool2.id.includes("context_search") || tool2.type === "context"
+    );
+    const includesWebSearchTool = currentTools?.some(
+      (tool2) => tool2.name.toLowerCase().includes("web_search") || tool2.id.includes("web_search") || tool2.type === "web_search"
+    );
+    console.log("[EXULU] Current tools: " + currentTools?.map((tool2) => tool2.name).join("\n"));
+    console.log("[EXULU] Includes context search tool: " + includesContextSearchTool);
+    console.log("[EXULU] Includes web search tool: " + includesWebSearchTool);
+    if (includesContextSearchTool) {
+      system += `
+
+
+
+              When you use a context search tool, you will include references to the items
+              retrieved from the tool call result inline in the response using this exact JSON format
+              (all on one line, no line breaks):
+              {item_name: <item_name>, item_id: <item_id>, context: <context_id>, chunk_id: <chunk_id>, chunk_index: <chunk_index>}
+
+              IMPORTANT formatting rules:
+              - Use the exact format shown above, all on ONE line
+              - Do NOT use quotes around field names or values
+              - Use the context ID from the tool result
+              - Include the file/item name, not the full path
+              - Separate multiple citations with spaces
+
+              Example: {item_name: document.pdf, item_id: abc123, context: my-context-id, chunk_id: chunk_456, chunk_index: 0}
+
+              The citations will be rendered as interactive badges in the UI.
+              `;
+    }
+    if (includesWebSearchTool) {
+      system += `
+
+
+              When you use a web search tool, you will include references to the results of the tool call result inline in the response using this exact JSON format
+              (all on one line, no line breaks):
+              {url: <url>, title: <title>, snippet: <snippet>}
+
+              IMPORTANT formatting rules:
+              - Use the exact format shown above, all on ONE line
+              - Do NOT use quotes around field names or values
+              - Separate multiple results with spaces
+
+              Example: {url: https://www.google.com, title: Google, snippet: The result of the web search.}
+              `;
+    }
+    const agenticEntry = currentTools?.find((t) => t.id === "agentic_context_search");
+    const agenticToolKey = agenticEntry ? sanitizeToolName(agenticEntry.name) : void 0;
+    const retrievalGuard = retrievalBudgetGuard(
+      resolveRetrievalCallBudget(toolConfigs),
+      agenticToolKey,
+      Object.keys(tools)
+    );
+    const turnBudget = resolveTurnStepBudget(maxStepCount, agent);
     const result = streamText({
       temperature: 0,
       // TODO Make this configurable
@@ -12257,10 +12390,9 @@ When a tool execution is not approved by the user, do not retry it unless explic
           `Chat stream error: ${error instanceof Error ? error.message : JSON.stringify(error)}`
         );
       },
-      // provide more loops for skills because they are more complex to execute
-      // todo allow configuring this per skill
-      prepareStep: finalAnswerGuard(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? (currentSkills?.length ? 10 : 5)),
-      stopWhen: [stepCountIs(maxStepCount ?? resolveMaxStepsFromToolConfigs(toolConfigs) ?? (currentSkills?.length ? 10 : 5)), hasToolCall("image_generation")]
+      // todo allow configuring the step budget per skill
+      prepareStep: composePrepareSteps(contextGuard(contextWindow), retrievalGuard, finalAnswerGuard(turnBudget)),
+      stopWhen: [stepCountIs(turnBudget), hasToolCall("image_generation")]
     });
     return {
       stream: result,
@@ -12271,19 +12403,14 @@ When a tool execution is not approved by the user, do not retry it unless explic
 };
 var getAgentMessages = async ({
   session,
-  user,
-  limit,
-  page
+  user
 }) => {
   const { db } = await postgresClient();
-  console.log(
-    "[EXULU] getting agent messages for session: " + session + " and user: " + user + " and page: " + page
-  );
-  const query = db.from("agent_messages").where({ session, user: user || null }).limit(limit);
-  if (page > 0) {
-    query.offset((page - 1) * limit);
-  }
-  const messages = await query;
+  console.log("[EXULU] getting agent messages for session: " + session + " and user: " + user);
+  const messages = await db.from("agent_messages").where({ session, user: user || null }).orderBy([
+    { column: "createdAt", order: "asc" },
+    { column: "id", order: "asc" }
+  ]);
   return messages;
 };
 var getSession = async ({ sessionID }) => {
@@ -12386,6 +12513,151 @@ ${SUGGESTIONS_SYSTEM_PROMPT}` : SUGGESTIONS_SYSTEM_PROMPT;
   };
 };
 
+// src/exulu/resolve-context-window.ts
+var resolveContextWindow = async ({
+  modelId,
+  exuluProvider
+}) => {
+  if (process.env.EXULU_USE_LITELLM === "true") {
+    const entry = await findLiteLLMModel(modelId);
+    const fromCatalog = entry?.max_input_tokens ?? entry?.max_tokens;
+    if (fromCatalog != null && fromCatalog > 0) return fromCatalog;
+  } else if (exuluProvider) {
+    try {
+      const fromProvider = exuluProvider.maxContextLength;
+      if (fromProvider != null && fromProvider > 0) return fromProvider;
+    } catch {
+    }
+  }
+  console.warn(
+    `[EXULU] Unknown context window for model "${modelId}" \u2014 assuming ${DEFAULT_CONTEXT_WINDOW}. Check the LiteLLM catalog / provider template metadata.`
+  );
+  return DEFAULT_CONTEXT_WINDOW;
+};
+
+// src/exulu/active-streams.ts
+var active = /* @__PURE__ */ new Set();
+var markStreamActive = (sessionID) => {
+  active.add(sessionID);
+};
+var clearStreamActive = (sessionID) => {
+  active.delete(sessionID);
+};
+var isStreamActive = (sessionID) => active.has(sessionID);
+
+// src/exulu/compact-session.ts
+import { randomUUID } from "crypto";
+import { generateText as generateText6, validateUIMessages as validateUIMessages2 } from "ai";
+var CompactionInsufficientError = class extends Error {
+  constructor(reason) {
+    super(JSON.stringify({ code: COMPACTION_INSUFFICIENT, message: reason }));
+    this.name = "CompactionInsufficientError";
+  }
+};
+var MIN_TAIL_MESSAGES = 2;
+var SUMMARY_TOOL_OUTPUT_SLICE = 1500;
+var SUMMARY_TOOL_INPUT_SLICE = 200;
+var SUMMARY_SYSTEM = `You compress chat histories for an AI assistant. Produce a dense, factual summary of the conversation below. Preserve:
+- the user's intent and any outstanding requests
+- key facts, decisions, and constraints
+- files, artifacts, and session files touched \u2014 ALWAYS keep exact file and item names so they stay retrievable
+- errors encountered and how they were resolved
+- pending tasks and the current state of the work
+Do not invent information. Do not include pleasantries. Write compact prose or bullet points.`;
+var splitTail = (messages, tailTokenBudget) => {
+  const minTail = Math.min(MIN_TAIL_MESSAGES, messages.length);
+  let cut = messages.length;
+  let tokens = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const t = estimateMessageTokens(messages[i]);
+    const tailCount = messages.length - i;
+    if (tailCount > minTail && tokens + t > tailTokenBudget) break;
+    tokens += t;
+    cut = i;
+  }
+  return { head: messages.slice(0, cut), tail: messages.slice(cut) };
+};
+var serializeForSummary = (messages) => messages.map((m) => {
+  const parts = (m.parts ?? []).map((part) => {
+    const p = part;
+    if (p.type === "text") return p.text ?? "";
+    if (p.type === "file") return `[file: ${p.filename ?? p.url ?? "attachment"}]`;
+    if (p.type === "reasoning" || p.type === "step-start") return "";
+    if (p.type?.startsWith("tool-") || p.type === "dynamic-tool") {
+      const out = p.output?.value ?? p.output;
+      const outText = typeof out === "string" ? out : JSON.stringify(out ?? "");
+      return `[tool ${p.type}: ${JSON.stringify(p.input ?? {}).slice(0, SUMMARY_TOOL_INPUT_SLICE)}] \u2192 ${outText.slice(0, SUMMARY_TOOL_OUTPUT_SLICE)}`;
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+  return `${m.role.toUpperCase()}:
+${parts}`;
+}).join("\n\n");
+var compactSession = async ({
+  sessionID,
+  user,
+  languageModel,
+  contextWindow,
+  steer,
+  modelId,
+  summarize
+}) => {
+  const budget = deriveContextBudget(contextWindow);
+  const rows = await getAgentMessages({ session: sessionID, user: user.id });
+  const all = await validateUIMessages2({ messages: rows.map((r) => JSON.parse(r.content)) });
+  const history = sliceHistoryAtCheckpoint(all);
+  const { head, tail } = splitTail(history, budget.compactionTailTokens);
+  if (head.length === 0) {
+    throw new CompactionInsufficientError(
+      "There is nothing left to compact \u2014 the recent messages already form the whole context. Start a new chat instead."
+    );
+  }
+  let corpus = serializeForSummary(head);
+  const originalTokens = estimateTokens(corpus);
+  corpus = truncateToolOutput(corpus, contextWindow, "history", 0.3, Math.floor(budget.usableWindow * 0.8) * 4);
+  const system = steer?.trim() ? `${SUMMARY_SYSTEM}
+
+Focus especially on: ${steer.trim()}` : SUMMARY_SYSTEM;
+  const doSummarize = summarize ?? (async ({ system: sys, prompt, maxOutputTokens }) => {
+    const { text } = await generateText6({
+      model: languageModel,
+      system: sys,
+      prompt,
+      temperature: 0,
+      maxRetries: 2,
+      maxOutputTokens
+    });
+    return text;
+  });
+  const summary = await doSummarize({ system, prompt: corpus, maxOutputTokens: budget.summaryBudgetTokens });
+  const summaryTokens = estimateTokens(summary);
+  let tailTokens = 0;
+  for (const m of tail) tailTokens += estimateMessageTokens(m);
+  const occupancyEstimate = summaryTokens + tailTokens;
+  if (occupancyEstimate >= budget.blockThreshold) {
+    throw new CompactionInsufficientError(
+      "Compacting cannot shrink this conversation below the context limit \u2014 a recent message or output is too large by itself. Start a new chat."
+    );
+  }
+  const compaction = {
+    coversUpTo: head[head.length - 1].id,
+    originalTokens,
+    summaryTokens,
+    occupancyEstimate,
+    ...steer?.trim() ? { steer: steer.trim() } : {}
+  };
+  const checkpoint = {
+    id: `compaction_${randomUUID()}`,
+    role: "user",
+    parts: [{ type: "text", text: `[Conversation summary \u2014 earlier messages were compacted]
+
+${summary}` }],
+    metadata: { compaction }
+  };
+  await saveChat({ session: sessionID, user: user.id, messages: [checkpoint], ...modelId ? { model: modelId } : {} });
+  return { checkpoint, occupancyEstimate, originalTokens, summaryTokens };
+};
+
 // src/exulu/transcribe.ts
 var TranscriptionError = class extends Error {
   constructor(upstreamStatus, message) {
@@ -12751,7 +13023,7 @@ function checkApiKeyScope(user, agentId) {
 import "express";
 import {
   streamText as streamText2,
-  generateText as generateText6,
+  generateText as generateText7,
   stepCountIs as stepCountIs2,
   jsonSchema
 } from "ai";
@@ -12841,7 +13113,7 @@ function transformCompletion(text, inputTokens, outputTokens, ctx) {
 }
 
 // src/exulu/openai-gateway.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import "crypto-js";
 import express from "express";
 function convertOpenAIToolsToAiSdkTools(tools) {
@@ -13155,6 +13427,10 @@ var registerOpenAIGatewayRoutes = async (app, providers, tools, contexts, config
         }
         const providerapikey = resolved.apiKey;
         const languageModel = resolved.languageModel;
+        const contextWindow = await resolveContextWindow({
+          modelId: resolved.model.id,
+          exuluProvider: isLiteLLMEnabled() ? void 0 : resolved.exuluProvider
+        });
         const disabledTools = req.body.disabledTools ?? [];
         const enabledTools = await getEnabledTools(
           agent,
@@ -13179,12 +13455,50 @@ var registerOpenAIGatewayRoutes = async (app, providers, tools, contexts, config
           project?.id,
           void 0,
           languageModel,
-          agent
+          agent,
+          void 0,
+          contextWindow,
+          disabledTools
         );
+        const gatewayAgenticEntry = enabledTools?.find((t) => t.id === "agentic_context_search");
+        const gatewayAgenticKey = gatewayAgenticEntry ? sanitizeToolName(gatewayAgenticEntry.name) : void 0;
+        const gatewayRetrievalGuard = retrievalBudgetGuard(
+          resolveRetrievalCallBudget(agent.tools),
+          gatewayAgenticKey,
+          Object.keys(convertedTools)
+        );
+        const turnBudget = resolveTurnStepBudget(void 0, agent);
         const clientTools = Array.isArray(req.body.tools) ? req.body.tools : [];
         const activeTools = clientTools.length > 0 ? convertOpenAIToolsToAiSdkTools(clientTools) : convertedTools;
         const openaiMessages = req.body.messages ?? [];
         const { systemPrompt: requestSystemPrompt, coreMessages } = convertOpenAIMessagesToModelMessages(openaiMessages);
+        const gatewayBudget = deriveContextBudget(contextWindow);
+        const IMAGE_TOKEN_ALLOWANCE = 1e3;
+        let imageCount = 0;
+        const textOnlyMessages = openaiMessages.map((m) => {
+          if (!Array.isArray(m.content)) return m;
+          return {
+            ...m,
+            content: m.content.map((p) => {
+              if (p && typeof p === "object" && "image_url" in p && p.image_url) {
+                imageCount += 1;
+                return { ...p, image_url: { url: "[image]" } };
+              }
+              return p;
+            })
+          };
+        });
+        const promptTokens = estimateTokens(JSON.stringify(textOnlyMessages)) + imageCount * IMAGE_TOKEN_ALLOWANCE;
+        if (promptTokens >= gatewayBudget.blockThreshold) {
+          res.status(400).json({
+            error: {
+              message: `This request is ~${promptTokens.toLocaleString("en-US")} tokens, which exceeds the model's usable context window (${gatewayBudget.usableWindow.toLocaleString("en-US")} tokens). Reduce the conversation history.`,
+              type: "invalid_request_error",
+              code: "context_length_exceeded"
+            }
+          });
+          return;
+        }
         const agentInstructions = agent.instructions ?? "";
         const systemParts = [
           agentInstructions ? `You are an agent named: ${agent.name}
@@ -13194,7 +13508,7 @@ ${project.description}` : ""}` : "",
           requestSystemPrompt
         ].filter(Boolean);
         const systemPrompt = systemParts.join("\n\n");
-        const completionId = `chatcmpl-${randomUUID()}`;
+        const completionId = `chatcmpl-${randomUUID2()}`;
         const created = Math.floor(Date.now() / 1e3);
         const hasTools = Object.keys(activeTools).length > 0;
         const ctx = { completionId, created, modelId };
@@ -13208,7 +13522,8 @@ ${project.description}` : ""}` : "",
             messages: coreMessages,
             tools: hasTools ? activeTools : void 0,
             maxRetries: 2,
-            stopWhen: clientTools.length > 0 ? void 0 : [stepCountIs2(5)],
+            prepareStep: clientTools.length > 0 ? void 0 : composePrepareSteps(contextGuard(contextWindow), gatewayRetrievalGuard, finalAnswerGuard(turnBudget)),
+            stopWhen: clientTools.length > 0 ? void 0 : [stepCountIs2(turnBudget)],
             onError: (error) => {
               console.error("[OPENAI GATEWAY] stream error:", error);
             }
@@ -13241,13 +13556,14 @@ ${project.description}` : ""}` : "",
           const usage = await result.usage;
           await writeStatistics(agent, project, user, usage.inputTokens ?? 0, usage.outputTokens ?? 0);
         } else {
-          const { text, usage } = await generateText6({
+          const { text, usage } = await generateText7({
             model: languageModel,
             system: systemPrompt || void 0,
             messages: coreMessages,
             tools: hasTools ? activeTools : void 0,
             maxRetries: 2,
-            stopWhen: clientTools.length > 0 ? void 0 : [stepCountIs2(5)]
+            prepareStep: clientTools.length > 0 ? void 0 : composePrepareSteps(contextGuard(contextWindow), gatewayRetrievalGuard, finalAnswerGuard(turnBudget)),
+            stopWhen: clientTools.length > 0 ? void 0 : [stepCountIs2(turnBudget)]
           });
           res.json(transformCompletion(text, usage.inputTokens ?? 0, usage.outputTokens ?? 0, ctx));
           await writeStatistics(agent, project, user, usage.inputTokens ?? 0, usage.outputTokens ?? 0);
@@ -13745,7 +14061,7 @@ Mood: friendly and intelligent.
       });
       return;
     }
-    const uuid = randomUUID2();
+    const uuid = randomUUID3();
     const image_url = await uploadFile(Buffer.from(image_base64, "base64"), `${uuid}.png`, config, {
       contentType: "image/png"
     }, authenticationResult.user?.id, void 0, true);
@@ -13949,6 +14265,10 @@ Mood: friendly and intelligent.
       const providerapikey = resolved.apiKey;
       const resolvedLanguageModel = resolved.languageModel;
       const resolvedModelId = resolved.model.id;
+      const contextWindow = await resolveContextWindow({
+        modelId: resolved.model.id,
+        exuluProvider: isLiteLLMEnabled() ? void 0 : resolved.exuluProvider
+      });
       if (!!headers.stream) {
         const statistics = {
           label: agent.name,
@@ -13967,27 +14287,46 @@ Mood: friendly and intelligent.
         const instructions = customInstructions ? `${agent.instructions}
 
 ${customInstructions}` : agent.instructions;
-        const result = await provider.generateStream({
-          contexts,
-          agent,
-          user,
-          instructions,
-          session: headers.session,
-          message,
-          previousMessages,
-          currentTools: enabledTools,
-          currentSkills: enabledSkills,
-          approvedTools,
-          allExuluTools: tools,
-          languageModel: resolvedLanguageModel,
-          providerapikey,
-          toolConfigs: agent.tools,
-          exuluConfig: config,
-          req
-        });
+        if (headers.session) markStreamActive(headers.session);
+        let result;
+        try {
+          result = await provider.generateStream({
+            contexts,
+            agent,
+            user,
+            instructions,
+            session: headers.session,
+            message,
+            previousMessages,
+            currentTools: enabledTools,
+            currentSkills: enabledSkills,
+            approvedTools,
+            allExuluTools: tools,
+            languageModel: resolvedLanguageModel,
+            providerapikey,
+            toolConfigs: agent.tools,
+            exuluConfig: config,
+            req,
+            contextWindow,
+            disabledTools
+          });
+        } catch (err) {
+          if (headers.session) clearStreamActive(headers.session);
+          if (err instanceof ContextCompactionRequiredError) {
+            res.status(413).send(err.message);
+            return;
+          }
+          throw err;
+        }
         result.stream.consumeStream();
         result.stream.pipeUIMessageStreamToResponse(res, {
           messageMetadata: ({ part }) => {
+            if (part.type === "finish-step") {
+              return {
+                lastStepInputTokens: part.usage.inputTokens,
+                lastStepOutputTokens: part.usage.outputTokens
+              };
+            }
             if (part.type === "finish") {
               return {
                 totalTokens: part.totalUsage.totalTokens,
@@ -14004,22 +14343,20 @@ ${customInstructions}` : agent.instructions;
           sendSources: true,
           onError: (error) => {
             console.error("[EXULU] chat response error.", error);
-            if (error == null) {
-              return "unknown error";
-            }
-            if (typeof error === "string") {
-              return error;
-            }
-            if (error instanceof Error) {
-              return error.message;
-            }
-            return JSON.stringify(error);
+            if (headers.session) clearStreamActive(headers.session);
+            let message2;
+            if (error == null) message2 = "unknown error";
+            else if (typeof error === "string") message2 = error;
+            else if (error instanceof Error) message2 = error.message;
+            else message2 = JSON.stringify(error);
+            return mapStreamErrorMessage(message2);
           },
           generateMessageId: createIdGenerator({
             prefix: "msg_",
             size: 16
           }),
           onFinish: async ({ messages, isContinuation, isAborted, responseMessage }) => {
+            if (headers.session) clearStreamActive(headers.session);
             console.log(
               "[EXULU] onFinish",
               messages?.map((msg) => msg.parts?.map((part) => part.type === "text" ? part.text : null)).join("\n")
@@ -14081,33 +14418,129 @@ ${customInstructions}` : agent.instructions;
         const instructions = customInstructions ? `${agent.instructions}
 
 ${customInstructions}` : agent.instructions;
-        const response = await provider.generateSync({
-          contexts,
-          agent,
-          user,
-          req,
-          instructions,
-          session: headers.session,
-          inputMessages: [req.body.message],
-          currentTools: enabledTools,
-          currentSkills: enabledSkills,
-          allExuluTools: tools,
-          languageModel: resolvedLanguageModel,
-          providerapikey,
-          exuluConfig: config,
-          toolConfigs: agent.tools,
-          statistics: {
-            label: agent.name,
-            trigger: "agent"
-          },
-          onTokenUsage: async ({ inputTokens, outputTokens }) => {
+        let response;
+        try {
+          response = await provider.generateSync({
+            contexts,
+            agent,
+            user,
+            req,
+            instructions,
+            session: headers.session,
+            inputMessages: [req.body.message],
+            currentTools: enabledTools,
+            currentSkills: enabledSkills,
+            allExuluTools: tools,
+            languageModel: resolvedLanguageModel,
+            providerapikey,
+            exuluConfig: config,
+            toolConfigs: agent.tools,
+            contextWindow,
+            disabledTools,
+            statistics: {
+              label: agent.name,
+              trigger: "agent"
+            },
+            onTokenUsage: async ({ inputTokens, outputTokens }) => {
+            }
+          });
+        } catch (err) {
+          if (err instanceof ContextCompactionRequiredError) {
+            res.status(413).send(err.message);
+            return;
           }
-        });
+          throw err;
+        }
         res.status(200).json(response);
         return;
       }
     });
   };
+  const registerAgentCompactRoute = (slug) => {
+    app.post(slug + "/:instance", async (req, res) => {
+      const instance = req.params.instance;
+      if (!instance) {
+        res.status(400).json({ message: "Missing instance in request." });
+        return;
+      }
+      const sessionID = req.headers["session"] || null;
+      if (!sessionID) {
+        res.status(400).json({ message: "Missing session header." });
+        return;
+      }
+      const agent = await exuluApp.get().agent(instance);
+      if (!agent) {
+        res.status(404).json({ message: "Agent with id " + instance + " not found." });
+        return;
+      }
+      const authenticationResult = await requestValidators.authenticate(req);
+      if (!authenticationResult.user?.id) {
+        res.status(authenticationResult.code || 401).json({ detail: `${authenticationResult.message}` });
+        return;
+      }
+      const user = authenticationResult.user;
+      const hasAccessToAgent = await checkRecordAccess(agent, "read", user);
+      if (!hasAccessToAgent) {
+        res.status(401).json({ message: "You don't have access to this agent." });
+        return;
+      }
+      const { db } = await postgresClient();
+      const sessionRow = await db.from("agent_sessions").where({ id: sessionID }).first();
+      if (!sessionRow) {
+        res.status(404).json({ message: "Session not found for session ID: " + sessionID });
+        return;
+      }
+      const hasAccessToSession = await checkRecordAccess(sessionRow, "write", user);
+      if (!hasAccessToSession) {
+        res.status(401).json({ message: "You don't have access to this session." });
+        return;
+      }
+      if (isStreamActive(sessionID)) {
+        res.status(409).json({ message: "A response is still streaming for this session \u2014 try again when it finishes." });
+        return;
+      }
+      const overrideModelId = req.headers["x-exulu-model-override"];
+      const modelId = overrideModelId ?? agent.model;
+      if (!modelId) {
+        res.status(400).json({ message: `Agent ${agent.name} (${agent.id}) has no model configured.` });
+        return;
+      }
+      let resolved;
+      try {
+        resolved = await resolveModel({ modelId, user, providers, agent });
+      } catch (err) {
+        if (err instanceof ResolveModelError) {
+          const status = err.code === "MODEL_FORBIDDEN" ? 403 : 400;
+          res.status(status).json({ message: err.message, code: err.code });
+          return;
+        }
+        throw err;
+      }
+      const contextWindow = await resolveContextWindow({
+        modelId: resolved.model.id,
+        exuluProvider: isLiteLLMEnabled() ? void 0 : resolved.exuluProvider
+      });
+      const steer = typeof req.body?.steer === "string" ? req.body.steer : void 0;
+      try {
+        const result = await compactSession({
+          sessionID,
+          user,
+          languageModel: resolved.languageModel,
+          contextWindow,
+          steer,
+          modelId: resolved.model.id
+        });
+        res.json(result);
+      } catch (err) {
+        if (err instanceof CompactionInsufficientError) {
+          res.status(422).send(err.message);
+          return;
+        }
+        console.error("[EXULU] compactSession failed.", err);
+        res.status(500).json({ message: err instanceof Error ? err.message : "Compaction failed." });
+      }
+    });
+  };
   providers.forEach((provider) => {
     const slug = provider.slug;
     if (!slug) return;
@@ -14116,6 +14549,14 @@ ${customInstructions}` : agent.instructions;
   if (isLiteLLMEnabled() && providers.length > 0) {
     registerAgentRunRoute("/agents/litellm/run", providers[0]);
   }
+  providers.forEach((provider) => {
+    const slug = provider.slug;
+    if (!slug) return;
+    registerAgentCompactRoute(slug.replace(/\/run$/, "/compact"));
+  });
+  if (isLiteLLMEnabled() && providers.length > 0) {
+    registerAgentCompactRoute("/agents/litellm/compact");
+  }
   app.post("/agents/suggestions/:agentId", async (req, res) => {
     const agentId = req.params.agentId;
     if (!agentId) {
@@ -14467,7 +14908,7 @@ ${customInstructions}` : agent.instructions;
     const keys = [];
     const revisedPrompts = [];
     for (const img of images) {
-      const filename = `${randomUUID2()}.${img.extension}`;
+      const filename = `${randomUUID3()}.${img.extension}`;
       const key = `sessions/${sessionId}/images/${toolCallId}/${filename}`;
       const fullKey = await uploadFile(
         img.buffer,
@@ -14755,7 +15196,7 @@ ${style.markdown}` : params.prompt;
       (d) => `- ${d.presignedUrl} (prompt: "${d.prompt}", model: ${d.model}${d.styleName ? `, style: ${d.styleName}` : ""})`
     );
     const messageText = "The user generated and selected the following image(s) in this chat:\n" + lines.join("\n");
-    const messageId = randomUUID2();
+    const messageId = randomUUID3();
     const uiMessage = {
       id: messageId,
       role: "system",
@@ -15683,7 +16124,7 @@ ${style.markdown}` : params.prompt;
       res.status(404).json({ detail: "Skill not found." });
       return;
     }
-    const stagingKey = `user_${authResult.user.id}/skills/_staging/${randomUUID2()}${extension}`;
+    const stagingKey = `user_${authResult.user.id}/skills/_staging/${randomUUID3()}${extension}`;
     const fullKey = config.fileUploads?.s3prefix ? `${config.fileUploads.s3prefix.replace(/\/$/, "")}/${stagingKey}` : stagingKey;
     const uploadUrl = await getS3SignedUploadUrl(fullKey, contentType, config);
     res.json({ uploadUrl, stagingKey });
@@ -16714,7 +17155,7 @@ function buildUnifiedDiff(fromLines, toLines, fromLabel, toLabel) {
 
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import "express";
@@ -16819,7 +17260,7 @@ var ExuluMCP = class {
             throw new Error("Tool not found in converted tools array.");
           }
           const iterator = await convertedTool.execute(inputs, {
-            toolCallId: tool2.id + "_" + randomUUID3(),
+            toolCallId: tool2.id + "_" + randomUUID4(),
             messages: []
           });
           let result;
@@ -17011,7 +17452,7 @@ var ExuluMCP = class {
         transport = this.transports[sessionId];
       } else if (!sessionId && isInitializeRequest(req.body)) {
         transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => randomUUID3(),
+          sessionIdGenerator: () => randomUUID4(),
           onsessioninitialized: (sessionId2) => {
             this.transports[sessionId2] = transport;
           }
@@ -17992,7 +18433,7 @@ var ExuluEval = class {
 
 // src/templates/evals/index.ts
 import { z as z5 } from "zod";
-import { generateText as generateText7, Output as Output2 } from "ai";
+import { generateText as generateText8, Output as Output2 } from "ai";
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
     return new ExuluEval({
@@ -18037,7 +18478,7 @@ var llmAsJudgeEval = () => {
           rbacBypass: true
         });
         console.log("[EXULU] prompt", prompt);
-        const { output } = await generateText7({
+        const { output } = await generateText8({
           temperature: 0,
           model: resolved.languageModel,
           system: "",
@@ -18460,7 +18901,7 @@ After asking a question, use the Question Read tool to check if the user has ans
 
 // src/templates/tools/question/question-ask.ts
 import z7 from "zod";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var AnswerOptionSchema = z7.object({
   id: z7.string().describe("Unique identifier for the answer option"),
   text: z7.string().describe("The text of the answer option")
@@ -18514,15 +18955,15 @@ var QuestionAskTool = new ExuluTool({
       throw new Error("You don't have access to this session " + session.id + ".");
     }
     const answerOptionsWithIds = answerOptions.map((text) => ({
-      id: randomUUID4(),
+      id: randomUUID5(),
       text
     }));
     answerOptionsWithIds.push({
-      id: randomUUID4(),
+      id: randomUUID5(),
       text: "None of the above..."
     });
     const newQuestion = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       question,
       answerOptions: answerOptionsWithIds,
       status: "pending"
@@ -21303,10 +21744,10 @@ var MarkdownChunker = class {
 // ee/python/documents/processing/doc_processor.ts
 import * as fs3 from "fs";
 import * as path from "path";
-import { generateText as generateText8, Output as Output3 } from "ai";
+import { generateText as generateText9, Output as Output3 } from "ai";
 import { z as z12 } from "zod";
 import pLimit from "p-limit";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import * as mammoth from "mammoth";
 import TurndownService from "turndown";
 import WordExtractor from "word-extractor";
@@ -21760,7 +22201,7 @@ If the page contains a flow-chart, schematic, technical drawing or control board
 
 ### 7. Only populate \`corrected_text\` when \`needs_correction\` is true. If the OCR output is accurate, return \`needs_correction: false\` and \`corrected_content: null\`.
 `;
-  const result = await generateText8({
+  const result = await generateText9({
     model,
     output: Output3.object({
       schema: z12.object({
@@ -22181,7 +22622,7 @@ var loadFile = async (file, name, tempDir) => {
   if (!fileType) {
     throw new Error("[EXULU] File name does not include extension, extension is required for document processing.");
   }
-  const UUID = randomUUID5();
+  const UUID = randomUUID6();
   let buffer;
   if (Buffer.isBuffer(file)) {
     filePath = path.join(tempDir, `${UUID}.${fileType}`);
@@ -22211,7 +22652,7 @@ async function documentProcessor({
   if (!license["advanced-document-processing"]) {
     throw new Error("Advanced document processing is an enterprise feature, please add a valid Exulu enterprise license key to use it.");
   }
-  const uuid = randomUUID5();
+  const uuid = randomUUID6();
   const tempDir = path.join(process.cwd(), "temp", uuid);
   const localFilesAndFoldersToDelete = [tempDir];
   console.log(`[EXULU] Temporary directory for processing document ${name}: ${tempDir}`);