npm - @runtypelabs/sdk - Versions diffs - 1.7.3 → 1.8.1 - Mend

@runtypelabs/sdk 1.7.3 → 1.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.cjs CHANGED Viewed

@@ -327,6 +327,7 @@ __export(index_exports, {
   defaultWorkflow: () => defaultWorkflow,
   deployWorkflow: () => deployWorkflow,
   evaluateGeneratedRuntimeToolProposal: () => evaluateGeneratedRuntimeToolProposal,
+  gameWorkflow: () => gameWorkflow,
   getDefaultPlanPath: () => getDefaultPlanPath,
   getLikelySupportingCandidatePaths: () => getLikelySupportingCandidatePaths,
   isDiscoveryToolName: () => isDiscoveryToolName,
@@ -2909,8 +2910,8 @@ var scaffoldPhase = {
     ].join("\n");
   },
   interceptToolCall(toolName, _args, _ctx) {
-    const blockedTools = ["write_file", "read_file", "search_repo", "glob_files", "tree_directory", "list_directory", "restore_file_checkpoint"];
-    if (blockedTools.includes(toolName)) {
+    const blockedTools2 = ["write_file", "read_file", "search_repo", "glob_files", "tree_directory", "list_directory", "restore_file_checkpoint"];
+    if (blockedTools2.includes(toolName)) {
       return [
         `Blocked: ${toolName} is not available in deploy mode.`,
         "Use deploy_sandbox to deploy your code to a live sandbox instead of writing files to the local repo."
@@ -2949,6 +2950,7 @@ var deployPhase = {
       "",
       "deploy_sandbox takes:",
       "  - code: The full source code (written to main.ts/main.js/main.py)",
+      '  - files: Additional files (path \u2192 content), e.g. { "public/index.html": "<html>..." }',
       '  - packageJson: Dependencies as a JSON object, e.g. { "dependencies": { "express": "^4.18.2" } }',
       '  - language: "typescript" (default), "javascript", or "python"',
       "  - port: The port your server listens on (default: 3000)",
@@ -2962,7 +2964,8 @@ var deployPhase = {
       "  3. Include ALL dependencies in packageJson \u2014 nothing is pre-installed except Node.js built-ins.",
       "  4. If the deploy fails, read the error output, fix the code, and call deploy_sandbox again.",
       "  5. The sandbox is persistent \u2014 subsequent calls reuse the same sandbox.",
-      "  6. When the deploy succeeds and the preview URL is live, tell the user and end with TASK_COMPLETE."
+      "  6. When the deploy succeeds and the preview URL is live, tell the user and end with TASK_COMPLETE.",
+      "  7. For apps with HTML frontends, use the `files` parameter to write HTML/CSS/JS to separate files and serve them with express.static, rather than embedding HTML in template literals."
     ].join("\n");
   },
   buildToolGuidance(_state) {
@@ -2977,8 +2980,8 @@ var deployPhase = {
     return false;
   },
   interceptToolCall(toolName, _args, _ctx) {
-    const blockedTools = ["write_file", "read_file", "search_repo", "glob_files", "tree_directory", "list_directory", "restore_file_checkpoint"];
-    if (blockedTools.includes(toolName)) {
+    const blockedTools2 = ["write_file", "read_file", "search_repo", "glob_files", "tree_directory", "list_directory", "restore_file_checkpoint"];
+    if (blockedTools2.includes(toolName)) {
       return [
         `Blocked: ${toolName} is not available in deploy mode.`,
         "Use deploy_sandbox to deploy your code to a live sandbox instead of writing files to the local repo."
@@ -2986,8 +2989,13 @@ var deployPhase = {
     }
     return void 0;
   },
-  canAcceptCompletion(_state, trace) {
-    return trace.entries.some((entry) => entry.startsWith("deploy_sandbox"));
+  canAcceptCompletion(state, trace) {
+    if (trace.entries.some((entry) => entry.startsWith("deploy_sandbox"))) {
+      return true;
+    }
+    return state.sessions.some(
+      (s) => s.actionKeys?.some((key) => key.startsWith("deploy_sandbox"))
+    );
   },
   buildRecoveryMessage(state) {
     const recent = state.sessions.slice(-2);
@@ -3058,6 +3066,248 @@ var deployWorkflow = {
   }
 };
+// src/workflows/game-workflow.ts
+var blockedTools = ["write_file", "read_file", "search_repo", "glob_files", "tree_directory", "list_directory", "restore_file_checkpoint"];
+function blockLocalTools(toolName) {
+  if (blockedTools.includes(toolName)) {
+    return [
+      `Blocked: ${toolName} is not available in game deploy mode.`,
+      "Use deploy_sandbox to deploy your game to a live sandbox instead of writing files to the local repo."
+    ].join(" ");
+  }
+  return void 0;
+}
+var designPhase = {
+  name: "design",
+  description: "Understand game requirements and plan the approach",
+  buildInstructions(_state) {
+    return [
+      "--- Workflow Phase: Design ---",
+      "This is a game development task. You will build a game and deploy it to a live sandbox \u2014 you are NOT editing files in the local repository.",
+      "Quickly determine:",
+      "  1. What type of game (3D, 2D, platformer, racing, puzzle, etc.)",
+      "  2. Theme and visual style",
+      "  3. Core game mechanics (controls, scoring, win/lose conditions)",
+      "  4. Tech stack (Three.js, Phaser, vanilla Canvas/WebGL, etc.)",
+      "  5. Any specific dependencies needed",
+      "",
+      "Do NOT inspect the local repo or search for files to edit.",
+      "Do NOT write a plan file.",
+      "Once you understand the requirements, proceed to build and deploy."
+    ].join("\n");
+  },
+  buildToolGuidance(_state) {
+    return [
+      "This is a sandbox deploy task \u2014 do NOT use write_file, read_file, search_repo, glob_files, tree_directory, or list_directory.",
+      "Your primary tool is deploy_sandbox. Use it to deploy code to a persistent sandbox and get a live preview URL."
+    ];
+  },
+  isComplete(ctx) {
+    return ctx.state.sessions.length >= 1 || ctx.trace.entries.some((entry) => entry.startsWith("deploy_sandbox"));
+  },
+  buildTransitionSummary(_state, _nextPhaseName) {
+    return [
+      "Automatic phase transition: design \u2192 build.",
+      "Requirements understood. Build the game and deploy it using deploy_sandbox.",
+      "",
+      "MANDATORY: Use the `files` parameter for ALL game HTML/JS/CSS.",
+      "code = minimal Express static server (~4 lines), files = game assets.",
+      "NEVER embed HTML inside res.send() template literals."
+    ].join("\n");
+  },
+  interceptToolCall(toolName, _args, _ctx) {
+    return blockLocalTools(toolName);
+  },
+  shouldForceEndTurn(snapshot, _ctx) {
+    if (snapshot.pauseCount >= 12) {
+      return "design phase is looping without progressing \u2014 end the turn so the system can advance to build";
+    }
+    return void 0;
+  }
+};
+var buildPhase = {
+  name: "build",
+  description: "Build the game and deploy to sandbox with live preview",
+  buildInstructions(_state) {
+    return [
+      "--- Workflow Phase: Build ---",
+      "Build the game and deploy it using the deploy_sandbox tool.",
+      "",
+      "CRITICAL: Multi-file deployment pattern",
+      "  You MUST use the `files` parameter for the game HTML/JS/CSS.",
+      "  NEVER embed HTML inside a JavaScript template literal in Express `res.send()` \u2014 this WILL break",
+      "  because game code uses backticks (template literals) which cause nested backtick corruption.",
+      "",
+      "  Correct pattern:",
+      "    - code: A minimal Express static file server (~5 lines):",
+      "      ```",
+      '      const express = require("express");',
+      "      const app = express();",
+      '      app.use(express.static("public"));',
+      '      app.listen(3000, () => console.log("Server running on port 3000"));',
+      "      ```",
+      "    - files: Your game assets as separate files:",
+      "      {",
+      '        "public/index.html": "<!DOCTYPE html>...",',
+      '        "public/game.js": "// game logic...",',
+      '        "public/style.css": "body { margin: 0; }"',
+      "      }",
+      "",
+      "  WRONG pattern (DO NOT DO THIS):",
+      '    - code: `app.get("/", (req, res) => res.send(\\`<html>...game code with backticks...\\`))`',
+      "    - This breaks because game code uses template literals inside the res.send template literal.",
+      "",
+      "deploy_sandbox takes:",
+      "  - code: The server source code (written to main.ts/main.js/main.py)",
+      '  - files: Additional files (path \u2192 content), e.g. { "public/index.html": "<html>..." }',
+      '  - packageJson: Dependencies as a JSON object, e.g. { "dependencies": { "express": "^4.18.2", "three": "^0.170.0" } }',
+      '  - language: "javascript" (recommended for games), "typescript", or "python"',
+      "  - port: The port your server listens on (default: 3000)",
+      "  - startCommand: Custom start command (auto-detected by default)",
+      "",
+      "Guidelines:",
+      '  1. Use `language: "javascript"` \u2014 simpler for static file servers.',
+      "  2. The `code` param should be a minimal Express static server. ALL game code goes in `files`.",
+      "  3. Include ALL dependencies in packageJson (express, three, phaser, etc.).",
+      "  4. If the deploy fails, read the error output, fix the code, and call deploy_sandbox again.",
+      "  5. The sandbox is persistent \u2014 subsequent calls reuse the same sandbox.",
+      "  6. Load game libraries from CDN in your HTML (e.g., Three.js from unpkg/cdnjs) OR include them in packageJson.",
+      "  7. Make the game fullscreen by default (width: 100vw, height: 100vh, no margin/padding on body).",
+      "",
+      "STARTER TEMPLATES \u2014 Copy and customize based on the game type:",
+      "",
+      "ALL templates use this server code:",
+      '  code: `const express = require("express"); const app = express(); app.use(express.static("public")); app.listen(3000, () => console.log("Game server running on port 3000"));`',
+      '  packageJson: { "dependencies": { "express": "^4.18.2" } }',
+      '  language: "javascript"',
+      "",
+      "THREE.JS (3D games \u2014 racing, flying, FPS, etc.):",
+      "  files: {",
+      '    "public/index.html": HTML with <script type="importmap">{"imports":{"three":"https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js"}}</script> and <script type="module" src="game.js"></script>',
+      '    "public/game.js": Import three, create scene/camera/renderer, game loop with requestAnimationFrame',
+      "  }",
+      "",
+      "PHASER (2D games \u2014 platformers, shooters, puzzles):",
+      "  files: {",
+      '    "public/index.html": HTML with <script src="https://cdn.jsdelivr.net/npm/phaser@3.80.1/dist/phaser.min.js"></script> and <script src="game.js"></script>',
+      '    "public/game.js": Phaser.Game config with scenes, preload/create/update lifecycle',
+      "  }",
+      "",
+      "CANVAS 2D (simple games \u2014 pong, snake, breakout):",
+      "  files: {",
+      '    "public/index.html": HTML with <canvas id="game" width="800" height="600"></canvas> and <script src="game.js"></script>',
+      '    "public/game.js": Get canvas context, game loop with requestAnimationFrame, draw calls',
+      "  }"
+    ].join("\n");
+  },
+  buildToolGuidance(_state) {
+    return [
+      "Your primary tool is deploy_sandbox. Call it with code (Express static server), files (game HTML/JS/CSS), and packageJson.",
+      "ALWAYS use the `files` parameter for game HTML, JavaScript, and CSS \u2014 NEVER embed them in template literals.",
+      "Do NOT use write_file, read_file, search_repo, glob_files, tree_directory, or list_directory.",
+      "You may use run_sandbox_code for quick one-off tests if needed."
+    ];
+  },
+  isComplete() {
+    return false;
+  },
+  interceptToolCall(toolName, args, _ctx) {
+    const localBlock = blockLocalTools(toolName);
+    if (localBlock) return localBlock;
+    if (toolName === "deploy_sandbox" && args) {
+      const hasFiles = args.files && typeof args.files === "object" && Object.keys(args.files).length > 0;
+      const codeStr = typeof args.code === "string" ? args.code : "";
+      const embedsHtml = /res\.send\s*\(/.test(codeStr) && /<html|<body|<script/i.test(codeStr);
+      if (!hasFiles && embedsHtml) {
+        return [
+          "Blocked: You are embedding HTML inside res.send() \u2014 this will break due to nested template literals.",
+          "You MUST use the `files` parameter. Put your game HTML/JS/CSS in files and use a minimal Express static server for code.",
+          'Example: code: `const express = require("express"); const app = express(); app.use(express.static("public")); app.listen(3000);`',
+          'files: { "public/index.html": "<!DOCTYPE html>...", "public/game.js": "// game code" }'
+        ].join("\n");
+      }
+    }
+    return void 0;
+  },
+  canAcceptCompletion(_state, trace) {
+    return trace.entries.some((entry) => entry.startsWith("deploy_sandbox"));
+  },
+  buildRecoveryMessage(state) {
+    const recent = state.sessions.slice(-2);
+    if (recent.length < 2) return void 0;
+    const noProgress = recent.every(
+      (s) => s.hadTextOutput === false && s.wroteFiles === false
+    );
+    if (!noProgress) return void 0;
+    return [
+      "Recovery instruction:",
+      "You should be deploying the game using deploy_sandbox with the `files` parameter.",
+      "Use `code` for a minimal Express static server and `files` for game HTML/JS/CSS.",
+      "NEVER embed HTML in a JavaScript template literal \u2014 use separate files."
+    ].join("\n");
+  },
+  shouldForceEndTurn(snapshot, _ctx) {
+    if (snapshot.consecutiveDiscoveryPauseCount >= 8) {
+      return "build phase is looping on discovery tools instead of calling deploy_sandbox";
+    }
+    if (snapshot.actionKeyCount >= 4) {
+      return `the same action repeated ${snapshot.actionKeyCount} times \u2014 try a different approach`;
+    }
+    return void 0;
+  }
+};
+var verifyPhase = {
+  name: "verify",
+  description: "Verify the game is running and playable",
+  buildInstructions(_state) {
+    return [
+      "--- Workflow Phase: Verify ---",
+      "The game has been deployed. Verify it is working:",
+      "  1. Check the server log for errors. If there are errors, fix and redeploy using deploy_sandbox.",
+      "  2. Tell the user the preview URL so they can play the game.",
+      "  3. End with TASK_COMPLETE.",
+      "",
+      "If the user reports issues, fix the code and redeploy."
+    ].join("\n");
+  },
+  buildToolGuidance(_state) {
+    return [
+      "Use deploy_sandbox to redeploy if fixes are needed.",
+      "Do NOT use local file system tools.",
+      "When the game is working, tell the user the preview URL and end with TASK_COMPLETE."
+    ];
+  },
+  isComplete() {
+    return false;
+  },
+  interceptToolCall(toolName, _args, _ctx) {
+    return blockLocalTools(toolName);
+  },
+  canAcceptCompletion(_state, trace) {
+    return trace.entries.some((entry) => entry.startsWith("deploy_sandbox"));
+  },
+  shouldForceEndTurn(snapshot, _ctx) {
+    if (snapshot.actionKeyCount >= 4) {
+      return `the same action repeated ${snapshot.actionKeyCount} times \u2014 try a different approach`;
+    }
+    return void 0;
+  }
+};
+function classifyVariant3() {
+  return "game";
+}
+var gameWorkflow = {
+  name: "game",
+  phases: [designPhase, buildPhase, verifyPhase],
+  classifyVariant: classifyVariant3,
+  async generateBootstrapContext() {
+    return void 0;
+  },
+  buildCandidateBlock() {
+    return "";
+  }
+};
 // src/endpoints.ts
 var FlowsEndpoint = class {
   constructor(client) {
@@ -5273,6 +5523,8 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     this.updateWorkflowPhase(state, this.createEmptyToolTrace(), workflow);
     let recordId;
     const localToolNames = options.localTools ? Object.keys(options.localTools) : void 0;
+    const builtinToolSchemas = await this.loadBuiltinToolSchemas(options.toolIds);
+    const compactInstructions = this.resolveCompactInstructions(options.compactInstructions, agent);
     if (!options.previousMessages) {
       if (workflow.generateBootstrapContext) {
         state.bootstrapContext = await workflow.generateBootstrapContext(
@@ -5306,65 +5558,101 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       if (session === 0 && !options.previousMessages) {
         state.originalMessage = options.message;
       }
-      const messages = this.buildSessionMessages(
+      const preparedSession = await this.prepareSessionContext(
         options.message,
         state,
         session,
         maxSessions,
         localToolNames,
         continuationContext,
-        workflow
+        workflow,
+        options.toolIds,
+        {
+          autoCompactTokenThreshold: options.autoCompactTokenThreshold,
+          contextLimitTokens: options.contextLimitTokens,
+          model: options.model,
+          compactStrategy: options.compactStrategy,
+          compactInstructions,
+          localTools: options.localTools,
+          builtinToolSchemas,
+          onContextCompaction: options.onContextCompaction,
+          onContextNotice: options.onContextNotice
+        }
       );
+      const {
+        messages,
+        requestContextManagement,
+        pendingNativeCompactionEvent
+      } = preparedSession;
       let sessionResult;
       const sessionData = {
         messages,
         debugMode: options.debugMode,
-        model: options.model
+        model: options.model,
+        ...options.toolIds?.length ? { tools: { toolIds: options.toolIds } } : {},
+        ...requestContextManagement ? { contextManagement: requestContextManagement } : {}
       };
       let sessionToolMessages = [];
-      if (useStream && options.localTools) {
-        const localToolResult = await this.executeWithLocalTools(
-          id,
-          sessionData,
-          sessionLocalTools || options.localTools,
-          sessionCallbacks,
-          {
-            onLocalToolResult: this.createLocalToolLoopGuard(state, sessionTrace, workflow)
-          },
-          state.taskName
-        );
-        if (!localToolResult) {
-          throw new Error("Agent stream ended without a complete event");
+      if (pendingNativeCompactionEvent) {
+        await this.emitContextCompactionEvent(options.onContextCompaction, {
+          phase: "start",
+          ...pendingNativeCompactionEvent
+        });
+      }
+      try {
+        if (useStream && options.localTools) {
+          const localToolResult = await this.executeWithLocalTools(
+            id,
+            sessionData,
+            sessionLocalTools || options.localTools,
+            sessionCallbacks,
+            {
+              onLocalToolResult: this.createLocalToolLoopGuard(state, sessionTrace, workflow)
+            },
+            state.taskName
+          );
+          if (!localToolResult) {
+            throw new Error("Agent stream ended without a complete event");
+          }
+          const { completeEvent, toolMessages: captured } = localToolResult;
+          sessionToolMessages = captured;
+          sessionResult = {
+            success: completeEvent.success,
+            result: completeEvent.finalOutput || "",
+            iterations: completeEvent.iterations,
+            totalCost: completeEvent.totalCost || 0,
+            totalTokens: completeEvent.totalTokens,
+            stopReason: completeEvent.stopReason,
+            error: completeEvent.error
+          };
+        } else if (useStream && options.streamCallbacks) {
+          const completeEvent = await this.executeWithCallbacks(
+            id,
+            sessionData,
+            sessionCallbacks || options.streamCallbacks
+          );
+          if (!completeEvent) {
+            throw new Error("Agent stream ended without a complete event");
+          }
+          sessionResult = {
+            success: completeEvent.success,
+            result: completeEvent.finalOutput || "",
+            iterations: completeEvent.iterations,
+            totalCost: completeEvent.totalCost || 0,
+            totalTokens: completeEvent.totalTokens,
+            stopReason: completeEvent.stopReason,
+            error: completeEvent.error
+          };
+        } else {
+          sessionResult = await this.execute(id, sessionData);
         }
-        const { completeEvent, toolMessages: captured } = localToolResult;
-        sessionToolMessages = captured;
-        sessionResult = {
-          success: completeEvent.success,
-          result: completeEvent.finalOutput || "",
-          iterations: completeEvent.iterations,
-          totalCost: completeEvent.totalCost || 0,
-          stopReason: completeEvent.stopReason,
-          error: completeEvent.error
-        };
-      } else if (useStream && options.streamCallbacks) {
-        const completeEvent = await this.executeWithCallbacks(
-          id,
-          sessionData,
-          sessionCallbacks || options.streamCallbacks
-        );
-        if (!completeEvent) {
-          throw new Error("Agent stream ended without a complete event");
+      } finally {
+        if (pendingNativeCompactionEvent) {
+          await this.emitContextCompactionEvent(options.onContextCompaction, {
+            phase: "complete",
+            ...pendingNativeCompactionEvent
+          });
         }
-        sessionResult = {
-          success: completeEvent.success,
-          result: completeEvent.finalOutput || "",
-          iterations: completeEvent.iterations,
-          totalCost: completeEvent.totalCost || 0,
-          stopReason: completeEvent.stopReason,
-          error: completeEvent.error
-        };
-      } else {
-        sessionResult = await this.execute(id, sessionData);
       }
       const toolTraceSummary = this.buildToolTraceSummary(sessionTrace);
       const effectiveSessionOutput = this.buildEffectiveSessionOutput(
@@ -5372,8 +5660,15 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         toolTraceSummary
       );
       const sessionCost = sessionResult.totalCost;
+      const sessionTokens = sessionResult.totalTokens;
       state.sessionCount = session + 1;
       state.totalCost += sessionCost;
+      if (sessionTokens) {
+        state.totalTokens = {
+          input: (state.totalTokens?.input || 0) + sessionTokens.input,
+          output: (state.totalTokens?.output || 0) + sessionTokens.output
+        };
+      }
       state.lastOutput = effectiveSessionOutput;
       state.lastError = sessionResult.stopReason === "error" ? sessionResult.error || "Agent session ended with an error." : void 0;
       state.lastStopReason = sessionResult.stopReason;
@@ -5381,6 +5676,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       state.sessions.push({
         index: session + 1,
         cost: sessionCost,
+        totalTokens: sessionTokens,
         iterations: sessionResult.iterations,
         stopReason: sessionResult.stopReason,
         outputPreview: effectiveSessionOutput.slice(0, 300),
@@ -5443,7 +5739,9 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         }
       }
       if (!state.messages) state.messages = [];
-      if (state.messages.length > 0 && messages.length > state.messages.length) {
+      if (this.isCompactHistoryMessageSet(messages)) {
+        state.messages = [...messages];
+      } else if (state.messages.length > 0 && messages.length > state.messages.length) {
         const newMessages = messages.slice(state.messages.length);
         state.messages.push(...newMessages);
       } else {
@@ -5494,6 +5792,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       status: state.status,
       sessionCount: state.sessionCount,
       totalCost: state.totalCost,
+      totalTokens: state.totalTokens,
       lastOutput: state.lastOutput,
       sessions: state.sessions,
       recordId
@@ -5507,45 +5806,383 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     const upper = output.toUpperCase();
     return _AgentsEndpoint.STOP_PHRASES.some((phrase) => upper.includes(phrase.toUpperCase()));
   }
+  resolveReservedOutputTokens(contextLimitTokens) {
+    if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0) {
+      return void 0;
+    }
+    return Math.max(8e3, Math.min(64e3, Math.floor(contextLimitTokens * 0.15)));
+  }
+  resolveEffectiveInputBudgetTokens(contextLimitTokens) {
+    if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0) {
+      return void 0;
+    }
+    const reservedOutputTokens = this.resolveReservedOutputTokens(contextLimitTokens) ?? 0;
+    return Math.max(1, contextLimitTokens - reservedOutputTokens);
+  }
+  resolveCompactStrategy(strategy, modelId) {
+    if (strategy === "summary_fallback") {
+      return "summary_fallback";
+    }
+    const normalizedModelId = modelId?.trim().toLowerCase() ?? "";
+    const supportsAnthropicNativeCompaction = normalizedModelId.includes("claude") || normalizedModelId.includes("anthropic");
+    if (strategy === "provider_native") {
+      return supportsAnthropicNativeCompaction ? "provider_native" : "summary_fallback";
+    }
+    return supportsAnthropicNativeCompaction ? "provider_native" : "summary_fallback";
+  }
+  estimateTextTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  estimateUnknownTokens(value) {
+    if (typeof value === "string") return this.estimateTextTokens(value);
+    try {
+      return this.estimateTextTokens(JSON.stringify(value));
+    } catch {
+      return 0;
+    }
+  }
+  estimateMessageContentTokens(content) {
+    if (typeof content === "string") return this.estimateTextTokens(content);
+    return content.reduce((total, part) => {
+      if (typeof part.text === "string") total += this.estimateTextTokens(part.text);
+      if (typeof part.image === "string") total += 85;
+      if (typeof part.data === "string") {
+        total += Math.min(200, this.estimateTextTokens(part.data));
+      }
+      return total + 4;
+    }, 0);
+  }
+  estimateToolCallTokens(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) return 0;
+    return toolCalls.reduce(
+      (sum, toolCall) => sum + 12 + this.estimateTextTokens(toolCall.toolName) + this.estimateUnknownTokens(toolCall.args),
+      0
+    );
+  }
+  estimateToolResultTokens(toolResults) {
+    if (!toolResults || toolResults.length === 0) return 0;
+    return toolResults.reduce(
+      (sum, toolResult) => sum + 12 + this.estimateTextTokens(toolResult.toolName) + this.estimateUnknownTokens(toolResult.result),
+      0
+    );
+  }
+  estimateMessageTokens(message) {
+    return 6 + this.estimateMessageContentTokens(message.content) + this.estimateToolCallTokens(message.toolCalls) + this.estimateToolResultTokens(message.toolResults);
+  }
+  estimateConversationTokens(messages) {
+    return messages.reduce((sum, message) => sum + this.estimateMessageTokens(message), 0);
+  }
+  estimateConversationBreakdown(messages) {
+    let historyTokens = 0;
+    let toolOutputTokens = 0;
+    for (const message of messages) {
+      const contentTokens = this.estimateMessageContentTokens(message.content);
+      const toolCallTokens = this.estimateToolCallTokens(message.toolCalls);
+      const toolResultTokens = this.estimateToolResultTokens(message.toolResults);
+      const messageTotal = 6 + contentTokens + toolCallTokens + toolResultTokens;
+      if (message.role === "tool") {
+        toolOutputTokens += messageTotal;
+      } else {
+        historyTokens += 6 + contentTokens + toolCallTokens;
+        toolOutputTokens += toolResultTokens;
+      }
+    }
+    return {
+      historyTokens,
+      toolOutputTokens,
+      estimatedInputTokens: historyTokens + toolOutputTokens
+    };
+  }
+  estimateToolDefinitionTokens(localTools, builtinToolSchemas) {
+    const localToolDefinitions = Object.entries(localTools || {}).map(([name, definition]) => ({
+      name,
+      description: definition.description,
+      parametersSchema: definition.parametersSchema
+    }));
+    const payload = [...localToolDefinitions, ...builtinToolSchemas];
+    if (payload.length === 0) return 0;
+    return this.estimateUnknownTokens(payload);
+  }
+  async loadBuiltinToolSchemas(toolIds) {
+    if (!toolIds || toolIds.length === 0) return [];
+    try {
+      const schemas = await this.client.get("/tools/schema", { toolIds });
+      return Array.isArray(schemas) ? schemas : [];
+    } catch {
+      return [];
+    }
+  }
+  buildDefaultCompactInstructions() {
+    return [
+      "Preserve changed files or best candidate paths.",
+      "Preserve verification or test results.",
+      "Preserve the current workflow phase and remaining work.",
+      "Preserve unresolved blockers or follow-up risks.",
+      "Preserve artifact references and offloaded tool outputs."
+    ].join(" ");
+  }
+  resolveCompactInstructions(optionInstructions, agent) {
+    if (typeof optionInstructions === "string" && optionInstructions.trim()) {
+      return optionInstructions.trim();
+    }
+    const config = agent.config;
+    if (!config || typeof config !== "object") {
+      return void 0;
+    }
+    const compactInstructions = config.compactInstructions;
+    return typeof compactInstructions === "string" && compactInstructions.trim() ? compactInstructions.trim() : void 0;
+  }
+  extractArtifactReferences(state) {
+    const references = /* @__PURE__ */ new Set();
+    const offloadPrefix = "[Output saved to ";
+    for (const message of state.messages ?? []) {
+      if (!message.toolResults) continue;
+      for (const toolResult of message.toolResults) {
+        if (typeof toolResult.result !== "string") continue;
+        let startIndex = 0;
+        while (startIndex < toolResult.result.length) {
+          const prefixIndex = toolResult.result.indexOf(offloadPrefix, startIndex);
+          if (prefixIndex === -1) break;
+          const pathStart = prefixIndex + offloadPrefix.length;
+          const closingBracket = toolResult.result.indexOf("]", pathStart);
+          if (closingBracket === -1) break;
+          const bracketContent = toolResult.result.slice(pathStart, closingBracket);
+          const separatorIndex = bracketContent.indexOf(" \u2014 ");
+          const pathText = separatorIndex === -1 ? bracketContent.trim() : bracketContent.slice(0, separatorIndex).trim();
+          if (pathText) {
+            references.add(pathText);
+          }
+          startIndex = closingBracket + 1;
+        }
+      }
+    }
+    if (state.planPath) {
+      references.add(state.planPath);
+    }
+    return [...references].slice(0, 8);
+  }
+  buildContextBudgetBreakdown(details) {
+    const conversationBreakdown = this.estimateConversationBreakdown(details.historyMessages);
+    const currentTurnTokens = this.estimateTextTokens(details.currentTurnContent);
+    const toolDefinitionTokens = this.estimateToolDefinitionTokens(
+      details.localTools,
+      details.builtinToolSchemas
+    );
+    const reservedOutputTokens = this.resolveReservedOutputTokens(details.contextLimitTokens);
+    const effectiveInputBudgetTokens = this.resolveEffectiveInputBudgetTokens(details.contextLimitTokens);
+    const summaryTokens = details.summaryText ? this.estimateTextTokens(
+      `${_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX}
+${details.summaryText}
+Do NOT redo any of the above work.`
+    ) : void 0;
+    return {
+      historyTokens: conversationBreakdown.historyTokens,
+      toolOutputTokens: conversationBreakdown.toolOutputTokens,
+      currentTurnTokens,
+      toolDefinitionTokens,
+      ...summaryTokens ? { summaryTokens } : {},
+      ...reservedOutputTokens ? { reservedOutputTokens } : {},
+      ...effectiveInputBudgetTokens ? { effectiveInputBudgetTokens } : {},
+      estimatedInputTokens: conversationBreakdown.estimatedInputTokens + currentTurnTokens + toolDefinitionTokens
+    };
+  }
+  async emitContextCompactionEvent(onContextCompaction, event) {
+    if (!onContextCompaction) return;
+    try {
+      await onContextCompaction(event);
+    } catch {
+    }
+  }
+  async emitContextNotice(onContextNotice, event) {
+    if (!onContextNotice) return;
+    try {
+      await onContextNotice(event);
+    } catch {
+    }
+  }
+  async buildCompactHistoryMessagesWithLifecycle(state, userContent, sessionIndex, details) {
+    const baseEvent = {
+      mode: details.mode,
+      strategy: details.strategy,
+      sessionIndex: sessionIndex + 1,
+      model: details.model,
+      estimatedTokens: details.beforeTokens,
+      thresholdTokens: details.thresholdTokens,
+      contextLimitTokens: details.contextLimitTokens,
+      effectiveInputBudgetTokens: details.effectiveInputBudgetTokens,
+      reservedOutputTokens: details.reservedOutputTokens,
+      beforeTokens: details.beforeTokens,
+      afterTokens: details.afterTokens,
+      breakdown: details.breakdown
+    };
+    await this.emitContextCompactionEvent(details.onContextCompaction, {
+      phase: "start",
+      ...baseEvent
+    });
+    const compactMessages = this.buildCompactHistoryMessages(
+      state,
+      userContent,
+      details.compactInstructions,
+      details.mode
+    );
+    await this.emitContextCompactionEvent(details.onContextCompaction, {
+      phase: "complete",
+      ...baseEvent
+    });
+    return compactMessages;
+  }
+  buildCompactHistoryMessages(state, userContent, compactInstructions, mode = "auto") {
+    const summary = this.generateCompactSummary(state, compactInstructions);
+    const prefix = mode === "forced" ? _AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX : _AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX;
+    return [
+      {
+        role: "system",
+        content: `${prefix}
+${summary}
+Do NOT redo any of the above work.`
+      },
+      {
+        role: "user",
+        content: userContent
+      }
+    ];
+  }
+  isCompactHistoryMessageSet(messages) {
+    if (messages.length === 0) return false;
+    const firstMessage = messages[0];
+    return firstMessage?.role === "system" && typeof firstMessage.content === "string" && (firstMessage.content.startsWith(_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX) || firstMessage.content.startsWith(_AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX));
+  }
   /**
    * Generate a compact summary of prior work for continuation context.
    * Used when compact mode is enabled to keep token usage low.
    */
-  generateCompactSummary(state) {
-    const sessionSummaries = (state.sessions ?? []).map(
-      (s) => `- Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) -- ${s.outputPreview.slice(0, 100)}`
+  generateCompactSummary(state, compactInstructions) {
+    const recentSessions = (state.sessions ?? []).slice(-5);
+    const sessionSummaries = recentSessions.map(
+      (session) => `- Session ${session.index}: ${session.stopReason} ($${session.cost.toFixed(4)}) ${session.outputPreview.slice(0, 160)}`
     ).join("\n");
+    const candidatePaths = Array.from(
+      new Set(
+        [
+          ...state.bestCandidatePath ? [state.bestCandidatePath] : [],
+          ...state.candidatePaths ?? []
+        ].filter(Boolean)
+      )
+    ).slice(0, 8);
+    const verificationSummary = state.bestCandidateVerified ? "Latest candidate verified." : state.bestCandidateNeedsVerification ? "Latest candidate still needs verification." : state.lastVerificationPassed ? "Latest verification passed." : state.verificationRequired ? "Verification is still required." : "No verification requirement recorded.";
+    const artifactReferences = this.extractArtifactReferences(state);
+    const pendingNextStep = state.lastStopReason === "complete" ? "Confirm nothing else remains before declaring the task complete." : `Continue the ${state.workflowPhase || "research"} phase without redoing prior work.`;
+    const instructions = compactInstructions || this.buildDefaultCompactInstructions();
     return [
-      `Task: ${state.taskName}`,
-      `Status: ${state.status}`,
-      `Workflow phase: ${state.workflowPhase || "research"}`,
-      `Sessions completed: ${state.sessionCount}`,
-      `Total cost: $${state.totalCost.toFixed(4)}`,
-      ...state.planPath ? [`Plan path: ${state.planPath}`] : [],
-      ...state.planWritten ? ["Plan written: yes"] : [],
-      ...state.bestCandidatePath ? [
-        `Best candidate: ${state.bestCandidatePath}`,
-        ...state.bestCandidateReason ? [`Candidate reason: ${state.bestCandidateReason}`] : []
-      ] : [],
-      ...state.bootstrapContext ? ["", state.bootstrapContext] : [],
+      "Task + Phase",
+      `- Task: ${state.taskName}`,
+      `- Status: ${state.status}`,
+      `- Workflow phase: ${state.workflowPhase || "research"}`,
+      `- Sessions completed: ${state.sessionCount}`,
+      `- Total cost: $${state.totalCost.toFixed(4)}`,
+      "",
+      "Completed Work",
+      ...sessionSummaries ? [sessionSummaries] : ["- No completed session summaries recorded yet."],
+      "",
+      "Changed Files / Candidate Paths",
+      ...candidatePaths.length > 0 ? candidatePaths.map((candidatePath) => `- ${candidatePath}`) : ["- No candidate paths recorded yet."],
+      ...state.planPath ? [`- Plan path: ${state.planPath}`] : [],
+      ...state.planWritten ? ["- Planning artifact has been written."] : [],
+      ...state.bestCandidateReason ? [`- Best candidate rationale: ${state.bestCandidateReason}`] : [],
       "",
-      "Session history:",
-      sessionSummaries,
+      "Verification Status",
+      `- ${verificationSummary}`,
+      ...state.lastError ? [`- Last error: ${state.lastError}`] : [],
       "",
-      "Last output (truncated):",
-      (state.lastOutput || "").slice(0, 1500)
+      "Pending Next Step",
+      `- ${pendingNextStep}`,
+      "",
+      "Artifact / Tool Output References",
+      ...artifactReferences.length > 0 ? artifactReferences.map((reference) => `- ${reference}`) : ["- No offloaded artifacts recorded."],
+      "",
+      "Compaction Instructions",
+      `- ${instructions}`,
+      "",
+      "Last Output (truncated)",
+      (state.lastOutput || "").slice(0, 1800) || "- No final output recorded yet."
     ].join("\n");
   }
   /**
    * Build messages for a session, injecting progress context for continuation sessions.
    * Optionally accepts continuation context for marathon resume scenarios.
    */
-  buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow) {
+  async buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow, builtinToolIds, compactionOptions) {
+    const prepared = await this.prepareSessionContext(
+      originalMessage,
+      state,
+      sessionIndex,
+      maxSessions,
+      localToolNames,
+      continuationContext,
+      workflow,
+      builtinToolIds,
+      compactionOptions
+    );
+    return prepared.messages;
+  }
+  async prepareSessionContext(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow, builtinToolIds, compactionOptions) {
     const wf = workflow ?? defaultWorkflow;
+    const compactInstructions = compactionOptions?.compactInstructions;
+    const resolvedStrategy = continuationContext?.compact ? "summary_fallback" : this.resolveCompactStrategy(compactionOptions?.compactStrategy, compactionOptions?.model);
+    const requestContextManagement = resolvedStrategy === "provider_native" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 ? {
+      compactStrategy: resolvedStrategy,
+      ...compactInstructions ? { compactInstructions } : {},
+      nativeCompaction: {
+        provider: "anthropic",
+        thresholdTokens: compactionOptions.autoCompactTokenThreshold
+      }
+    } : void 0;
+    const maybeEmitToolDefinitionWarning = async (breakdown) => {
+      if (sessionIndex !== 0) return;
+      if (typeof compactionOptions?.contextLimitTokens !== "number" || compactionOptions.contextLimitTokens <= 0) {
+        return;
+      }
+      if (breakdown.toolDefinitionTokens <= 0) return;
+      const ratio = breakdown.toolDefinitionTokens / compactionOptions.contextLimitTokens;
+      if (ratio < 0.1) return;
+      await this.emitContextNotice(compactionOptions?.onContextNotice, {
+        kind: "tool_definitions_warning",
+        sessionIndex: sessionIndex + 1,
+        model: compactionOptions?.model,
+        message: `Tool definitions consume about ${(ratio * 100).toFixed(1)}% of the ${compactionOptions.contextLimitTokens.toLocaleString()} token context window. Reduce the enabled tool set if context pressure remains high.`,
+        estimatedTokens: breakdown.toolDefinitionTokens,
+        contextLimitTokens: compactionOptions.contextLimitTokens,
+        effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+        reservedOutputTokens: breakdown.reservedOutputTokens
+      });
+    };
+    const buildNativeCompactionEvent = (mode, breakdown) => {
+      if (resolvedStrategy !== "provider_native" || typeof compactionOptions?.autoCompactTokenThreshold !== "number" || compactionOptions.autoCompactTokenThreshold <= 0 || breakdown.estimatedInputTokens < compactionOptions.autoCompactTokenThreshold) {
+        return void 0;
+      }
+      return {
+        mode,
+        strategy: resolvedStrategy,
+        sessionIndex: sessionIndex + 1,
+        model: compactionOptions?.model,
+        estimatedTokens: breakdown.estimatedInputTokens,
+        thresholdTokens: compactionOptions.autoCompactTokenThreshold,
+        contextLimitTokens: compactionOptions.contextLimitTokens,
+        effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+        reservedOutputTokens: breakdown.reservedOutputTokens,
+        beforeTokens: breakdown.estimatedInputTokens,
+        breakdown
+      };
+    };
     const currentPhase = wf.phases.find((p) => p.name === state.workflowPhase);
     const toolGuidanceLines = currentPhase?.buildToolGuidance(state) ?? [];
     const isDeployWorkflow = wf.name === "deploy";
-    const toolsBlock = localToolNames?.length ? [
+    const localToolsBlock = localToolNames?.length ? [
       "",
       "--- Local Tools ---",
       `You have access to tools (${localToolNames.join(", ")}) that execute directly on the user's machine.`,
@@ -5555,6 +6192,14 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       ...toolGuidanceLines,
       ...isDeployWorkflow ? [] : ["Always use write_file to save your output so the user can run it immediately."]
     ].join("\n") : "";
+    const builtinToolNames = builtinToolIds?.map((id) => id.replace(/^builtin:/, ""));
+    const builtinToolsBlock = builtinToolNames?.length ? [
+      "",
+      "--- Built-in Tools ---",
+      `You have access to built-in tools (${builtinToolNames.join(", ")}) for web search, web scraping, image generation, and other capabilities.`,
+      "Use these tools when the task requires information from the web, generating images, or other capabilities beyond local file operations."
+    ].join("\n") : "";
+    const toolsBlock = localToolsBlock + builtinToolsBlock;
     const bootstrapBlock = state.bootstrapContext ? ["", "--- Initial Repository Discovery ---", state.bootstrapContext].join("\n") : "";
     const phaseBlock = ["", this.buildPhaseInstructions(state, wf)].join("\n");
     const candidateBlock = wf.buildCandidateBlock?.(state) ?? "";
@@ -5562,25 +6207,16 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     if (continuationContext && sessionIndex === 0) {
       const defaultContinueMessage = "Continue the task. Review your prior work above and proceed with any remaining work. If everything is already complete, respond with TASK_COMPLETE.";
       const userMessage = continuationContext.newUserMessage || defaultContinueMessage;
-      if (continuationContext.compact) {
-        const summary = this.generateCompactSummary(state);
-        const messages2 = [
-          {
-            role: "system",
-            content: `You are continuing a previously completed task. Here is a summary of prior work:
-${summary}
-Do NOT redo any of the above work.`
-          },
-          {
-            role: "user",
-            content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n")
-          }
-        ];
-        return messages2;
-      }
-      const messages = [
+      const userContent = [
+        userMessage,
+        phaseBlock,
+        toolsBlock,
+        bootstrapBlock,
+        candidateBlock,
+        "",
+        multiSessionInstruction
+      ].join("\n");
+      const fullHistoryMessages = [
         ...continuationContext.previousMessages,
         {
           role: "system",
@@ -5588,14 +6224,79 @@ Do NOT redo any of the above work.`
         },
         {
           role: "user",
-          content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n")
+          content: userContent
         }
       ];
-      return messages;
+      const summaryText = this.generateCompactSummary(state, compactInstructions);
+      const breakdown = this.buildContextBudgetBreakdown({
+        historyMessages: continuationContext.previousMessages,
+        currentTurnContent: userContent,
+        localTools: compactionOptions?.localTools,
+        builtinToolSchemas: compactionOptions?.builtinToolSchemas || [],
+        summaryText,
+        contextLimitTokens: compactionOptions?.contextLimitTokens
+      });
+      await maybeEmitToolDefinitionWarning(breakdown);
+      if (continuationContext.compact) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            userContent,
+            sessionIndex,
+            {
+              mode: "forced",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      if (resolvedStrategy === "summary_fallback" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 && breakdown.estimatedInputTokens >= compactionOptions.autoCompactTokenThreshold) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            userContent,
+            sessionIndex,
+            {
+              mode: "auto",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      return {
+        messages: fullHistoryMessages,
+        requestContextManagement,
+        pendingNativeCompactionEvent: buildNativeCompactionEvent("auto", breakdown)
+      };
     }
     if (sessionIndex === 0) {
       const content2 = [originalMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n");
-      return [{ role: "user", content: content2 }];
+      return {
+        messages: [{ role: "user", content: content2 }],
+        requestContextManagement
+      };
     }
     const recentSessions = state.sessions.slice(-5);
     const progressSummary = recentSessions.map(
@@ -5629,10 +6330,49 @@ Do NOT redo any of the above work.`
           ...historyMessages.slice(-MAX_HISTORY_MESSAGES)
         ];
       }
-      return [
+      const summaryText = this.generateCompactSummary(state, compactInstructions);
+      const breakdown = this.buildContextBudgetBreakdown({
+        historyMessages,
+        currentTurnContent: continuationContent,
+        localTools: compactionOptions?.localTools,
+        builtinToolSchemas: compactionOptions?.builtinToolSchemas || [],
+        summaryText,
+        contextLimitTokens: compactionOptions?.contextLimitTokens
+      });
+      await maybeEmitToolDefinitionWarning(breakdown);
+      const messages = [
         ...historyMessages,
         { role: "user", content: continuationContent }
       ];
+      if (resolvedStrategy === "summary_fallback" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 && breakdown.estimatedInputTokens >= compactionOptions.autoCompactTokenThreshold) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            continuationContent,
+            sessionIndex,
+            {
+              mode: "auto",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      return {
+        messages,
+        requestContextManagement,
+        pendingNativeCompactionEvent: buildNativeCompactionEvent("auto", breakdown)
+      };
     }
     const recoveryMessage = this.buildStuckTurnRecoveryMessage(state, wf);
     const content = [
@@ -5652,7 +6392,10 @@ Do NOT redo any of the above work.`
       "",
       "Continue where you left off. Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE."
     ].join("\n");
-    return [{ role: "user", content }];
+    return {
+      messages: [{ role: "user", content }],
+      requestContextManagement
+    };
   }
   /**
    * Upsert a record to sync long-task progress to the dashboard.
@@ -5702,6 +6445,8 @@ Do NOT redo any of the above work.`
     }
   }
 };
+_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX = "You are continuing a long-running task. Here is a compact summary of prior work:";
+_AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX = "You are continuing a previously completed task. Here is a summary of prior work:";
 /** Stop phrases that indicate the agent considers its task complete. */
 _AgentsEndpoint.STOP_PHRASES = [
   "DONE:",
@@ -7011,6 +7756,7 @@ var ClientEvalBuilder = class extends EvalBuilder {
   defaultWorkflow,
   deployWorkflow,
   evaluateGeneratedRuntimeToolProposal,
+  gameWorkflow,
   getDefaultPlanPath,
   getLikelySupportingCandidatePaths,
   isDiscoveryToolName,