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

@runtypelabs/sdk 1.8.0 → 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

@@ -3108,7 +3108,11 @@ var designPhase = {
   buildTransitionSummary(_state, _nextPhaseName) {
     return [
       "Automatic phase transition: design \u2192 build.",
-      "Requirements understood. Build the game and deploy it using deploy_sandbox with the files parameter."
+      "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) {
@@ -3168,7 +3172,32 @@ var buildPhase = {
       "  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)."
+      "  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) {
@@ -3182,8 +3211,23 @@ var buildPhase = {
   isComplete() {
     return false;
   },
-  interceptToolCall(toolName, _args, _ctx) {
-    return blockLocalTools(toolName);
+  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"));
@@ -5479,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(
@@ -5512,7 +5558,7 @@ 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,
@@ -5520,61 +5566,93 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         localToolNames,
         continuationContext,
         workflow,
-        options.toolIds
+        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,
-        ...options.toolIds?.length ? { tools: { toolIds: options.toolIds } } : {}
+        ...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,
-          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");
+      } 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,
-          totalTokens: completeEvent.totalTokens,
-          stopReason: completeEvent.stopReason,
-          error: completeEvent.error
-        };
-      } else {
-        sessionResult = await this.execute(id, sessionData);
       }
       const toolTraceSummary = this.buildToolTraceSummary(sessionTrace);
       const effectiveSessionOutput = this.buildEffectiveSessionOutput(
@@ -5661,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 {
@@ -5726,41 +5806,379 @@ 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}`] : [],
+      "",
+      "Verification Status",
+      `- ${verificationSummary}`,
+      ...state.lastError ? [`- Last error: ${state.lastError}`] : [],
+      "",
+      "Pending Next Step",
+      `- ${pendingNextStep}`,
       "",
-      "Session history:",
-      sessionSummaries,
+      "Artifact / Tool Output References",
+      ...artifactReferences.length > 0 ? artifactReferences.map((reference) => `- ${reference}`) : ["- No offloaded artifacts recorded."],
       "",
-      "Last output (truncated):",
-      (state.lastOutput || "").slice(0, 1500)
+      "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, builtinToolIds) {
+  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";
@@ -5789,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",
@@ -5815,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(
@@ -5856,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 = [
@@ -5879,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.
@@ -5929,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:",