@sentry/junior 0.96.0 → 0.97.0

package/dist/{chunk-IYM2SIVG.js → chunk-XIRPQQVE.js}

@@ -10,7 +10,25 @@ import {
   persistRunningSessionRecord,
   persistTimeoutSessionRecord,
   persistYieldSessionRecord
-} from "./chunk-UKHVMPX5.js";
+} from "./chunk-WGXMTFNU.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  addAgentTurnUsage,
+  hasAgentTurnUsage
+} from "./chunk-WJOSZOON.js";
+import {
+  loadConnectedMcpProviders,
+  loadConversationProjection,
+  openConversationProjection,
+  recordAuthorizationRequested,
+  recordMcpProviderConnected,
+  recordToolExecutionStarted
+} from "./chunk-GUAP3H7O.js";
+import {
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
+  updateConversationStats
+} from "./chunk-3F4OPKGF.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxInstance,
@@ -20,66 +38,58 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-BYZWPRJA.js";
+} from "./chunk-H66UCBPW.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-CM5EZD5F.js";
 import {
-  renderAdvisorRequest
-} from "./chunk-WM6KHPBQ.js";
-import {
-  addAgentTurnUsage,
-  commitMessages,
-  hasAgentTurnUsage,
-  loadConnectedMcpProviders,
-  loadProjection,
-  recordAuthorizationRequested,
-  recordMcpProviderConnected,
-  recordToolExecutionStarted
-} from "./chunk-MNTINMWR.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-5C6XTTFI.js";
-import {
-  SlackActionError,
   createPluginHookRunner,
-  downloadPrivateSlackFile,
-  getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
   getPlugins,
-  getSlackClient,
   getSlackToolContext,
+  resolveChannelCapabilities
+} from "./chunk-5HLDPVYS.js";
+import {
+  SlackActionError,
+  downloadPrivateSlackFile,
+  getFilePermalink,
+  getSlackClient,
   isConversationScopedChannel,
   isDmChannel,
   normalizeSlackConversationId,
-  resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-S5KZ5LPG.js";
+} from "./chunk-WTYEKPXU.js";
 import {
   createPluginLogger
-} from "./chunk-2NAZZPPS.js";
-import {
-  SANDBOX_DATA_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_WORKSPACE_ROOT,
-  sandboxSkillDir,
-  sandboxSkillFile,
-  sleep
-} from "./chunk-CZEX6KIQ.js";
+} from "./chunk-EOWXRY5E.js";
 import {
+  contextProvenance,
   getAgentStepStore,
   getConversationStore,
   getDb,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-RITD7E5L.js";
+} from "./chunk-35BNLDOJ.js";
 import {
+  SANDBOX_DATA_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_WORKSPACE_ROOT,
+  sandboxSkillDir,
+  sandboxSkillFile
+} from "./chunk-G3E7SCME.js";
+import {
+  sleep
+} from "./chunk-4ZNGQH7C.js";
+import {
+  DEFAULT_HANDOFF_MODEL_PROFILE,
   GEN_AI_PROVIDER_NAME,
   GEN_AI_SERVER_ADDRESS,
   GEN_AI_SERVER_PORT,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
+  ModelProfileNotConfiguredError,
+  STANDARD_MODEL_PROFILE,
   TURN_CONTEXT_TAG,
   acquireActiveLock,
   botConfig,
@@ -96,13 +106,17 @@ import {
   isProviderRetryError,
   isToolResultError,
   isToolResultMessage,
+  modelIdForProfile,
   nextProviderRetry,
   normalizeSlackEmojiName,
   normalizeToolNameFromResult,
   renderCurrentInstruction,
   resolveGatewayModel,
-  stripRuntimeTurnContext
-} from "./chunk-YDVEH3SB.js";
+  retainRuntimeTurnContext,
+  stripRuntimeTurnContext,
+  trimTrailingAssistantMessages,
+  unwrapCurrentInstruction
+} from "./chunk-EEZCY5WX.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -114,7 +128,7 @@ import {
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes,
   toGenAiTextMetadata
-} from "./chunk-GY34VGP5.js";
+} from "./chunk-LVA4I4H7.js";
 import {
   parseDestination
 } from "./chunk-B7PUBQQM.js";
@@ -123,14 +137,14 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-PMNN6ST4.js";
+} from "./chunk-3ECW2K2O.js";
 import {
   CredentialUnavailableError,
   credentialContextSchema,
   pluginCatalogRuntime,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-L7CDEIVJ.js";
+} from "./chunk-LMJPRYHP.js";
 import {
   createActor,
   extractGenAiUsageAttributes,
@@ -157,16 +171,16 @@ import {
   startInactiveSpan,
   withActiveSpan
 } from "./chunk-6GWA276C.js";
-import {
-  listReferenceFiles,
-  soulPathCandidates,
-  worldPathCandidates
-} from "./chunk-6APU57E6.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
   parseSlackUserId
 } from "./chunk-7FBGKXPE.js";
+import {
+  listReferenceFiles,
+  soulPathCandidates,
+  worldPathCandidates
+} from "./chunk-3V7OFJZC.js";
 
 // src/chat/configuration/defaults.ts
 var installDefaults = {};
@@ -249,7 +263,7 @@ function shouldPropagateSandboxEgressTrace(host, config = {}) {
 }
 
 // src/chat/agent/index.ts
-import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
+import { Agent } from "@earendil-works/pi-agent-core";
 
 // src/chat/sandbox/skill-sandbox.ts
 import fs from "fs/promises";
@@ -672,7 +686,8 @@ function buildTurnResult(input) {
     usage,
     thinkingSelection,
     correlation,
-    assistantUserName
+    assistantUserName,
+    modelId
   } = input;
   const toolResults = newMessages.filter(isToolResultMessage);
   const assistantMessages = newMessages.filter(isAssistantMessage);
@@ -709,7 +724,7 @@ function buildTurnResult(input) {
       slackChannelId: correlation?.channelId,
       runId: correlation?.runId,
       assistantUserName,
-      modelId: botConfig.modelId
+      modelId
     };
     const markerAttributes = {
       "app.ai.no_reply_marker": true,
@@ -733,7 +748,7 @@ function buildTurnResult(input) {
         slackChannelId: correlation?.channelId,
         runId: correlation?.runId,
         assistantUserName,
-        modelId: botConfig.modelId
+        modelId
       },
       {
         "app.ai.no_reply_marker": true,
@@ -751,7 +766,7 @@ function buildTurnResult(input) {
         slackChannelId: correlation?.channelId,
         runId: correlation?.runId,
         assistantUserName,
-        modelId: botConfig.modelId
+        modelId
       },
       {
         "app.ai.tool_results": toolResults.length,
@@ -797,7 +812,7 @@ function buildTurnResult(input) {
   }
   const resolvedDiagnostics = {
     outcome: resolvedOutcome,
-    modelId: botConfig.modelId,
+    modelId,
     assistantMessageCount: assistantMessages.length,
     thinkingLevel: thinkingSelection.thinkingLevel,
     toolCalls,
@@ -2031,6 +2046,7 @@ var LOCAL_HEADER = "You are a helper assistant. Follow the personality section f
 var TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
 var TOOL_POLICY_RULES = [
   "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
+  "- Model upgrade: when `handoff` is available, call it immediately and as the only tool before handling any request to write, edit, review, debug, or substantially reason about code; make a multi-file change; perform architecture or root-cause analysis; do research-heavy synthesis or complex planning; or complete another task where a more capable model materially improves reliability. Choose the configured profile whose name best fits the task, or omit `profile` to use the default. Do not inspect or modify files first. After handoff, continue the same task normally.",
   "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
   "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
@@ -8367,252 +8383,33 @@ function createSystemTimeTool() {
   });
 }
 
-// src/chat/tools/advisor/tool.ts
-import {
-  Agent
-} from "@earendil-works/pi-agent-core";
+// src/chat/tools/handoff/tool.ts
 import { z as z33 } from "zod";
-function advisorChildConversationId(parentConversationId) {
-  return `advisor:${parentConversationId}`;
-}
-var ADVISOR_TOOL_DESCRIPTION = "High-reasoning technical advisor for planning and reviewing non-trivial work. Use it at two high-leverage checkpoints: (1) after enough investigation to understand the problem, but before implementation, to challenge the proposed approach, architecture, risks, alternatives, and verification plan; and (2) after implementation and initial validation, but before finalizing, committing, opening a PR, or reporting completion, to review the diff and results for correctness, regressions, omissions, and insufficient testing. Also consult it when requirements remain ambiguous, risk is unusually high, or repeated attempts have failed. Ask a focused question and provide self-contained, curated context such as requirements, exact evidence, constraints, relevant code, command output, proposed plan, alternatives considered, diff, and validation results. The advisor does not automatically receive the parent transcript and may use read-only tools to verify supplied context. For follow-ups, include new evidence, changes made, or the specific unresolved concern. Do not use it for greetings, routine formatting, simple deterministic edits, or as a substitute for direct investigation and validation.";
-var ADVISOR_SYSTEM_PROMPT = [
-  "You are a senior technical advisor for the executor.",
-  "Analyze the executor-supplied context deeply. Use read-only tools when direct inspection or verification would materially improve the advice.",
-  "Distinguish evidence from inference. Treat the advisor task as the focus for this call and the executor context as the starting evidence packet.",
-  "Do not assume access to parent transcript or tool output that was not included or gathered in this advisor call.",
-  "Use only the read-only tools provided to you.",
-  "Do not make user-visible side effects, post Slack messages, or mutate files. If a mutating action is needed, recommend it to the executor instead.",
-  "Identify the hard part, recommend a concrete plan or correction, call out blocking risks, and propose focused verification.",
-  "If the supplied context is insufficient, say exactly what additional evidence the executor needs to gather before acting.",
-  "Do not write user-facing prose.",
-  "Use concise technical memo sections when helpful: Assessment, Recommended Plan, Risks, Verification, Stop Conditions."
-].join("\n");
-function lastAssistantMessage(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (isAssistantMessage(message)) {
-      return message;
-    }
-  }
-  return void 0;
-}
-function failure(errorCode, text = `Advisor guidance is unavailable (${errorCode}). Continue only if the next step is clear from verified evidence.`) {
-  return {
-    ok: false,
-    status: "error",
-    error_code: errorCode,
-    memo: text
-  };
-}
-function success(memo) {
-  return {
-    ok: true,
-    status: "success",
-    memo
-  };
-}
-function hasReadOnlyToolAnnotations(annotations) {
-  return annotations?.readOnlyHint === true && annotations.destructiveHint !== true;
-}
-function createAdvisorToolDefinitions(definitions) {
-  return Object.fromEntries(
-    Object.entries(definitions).filter(
-      ([name, definition]) => name !== "callMcpTool" && name !== "searchMcpTools" && hasReadOnlyToolAnnotations(definition.annotations)
-    )
-  );
-}
-function createAdvisorTool(context) {
-  const conversationStore = () => context.conversationStore ?? getConversationStore();
-  const spanContext = context.logContext ?? {};
+var HANDOFF_TOOL_NAME = "handoff";
+function createHandoffTool(handoff) {
+  const profileSchema = z33.enum(handoff.profiles);
+  const defaultProfile = handoff.profiles[0];
+  const handoffResultSchema = juniorToolResultSchema.extend({
+    model_profile: profileSchema
+  });
+  const profileNames = handoff.profiles.map((profile) => `\`${profile}\``).join(", ");
   return zodTool({
-    description: ADVISOR_TOOL_DESCRIPTION,
+    description: `Permanently switch this conversation to a more capable model profile, replace prior context with a continuation summary, and continue the same task with the same workspace and all other normal tools. Available profiles: ${profileNames}. Omit profile to use \`${defaultProfile}\`. Call it as the only tool in the assistant message when the system tool policy requires a model upgrade.`,
+    executionMode: "sequential",
     inputSchema: z33.object({
-      question: z33.string().min(1).describe("Focused advisor question or decision point."),
-      context: z33.string().min(1).describe(
-        "Curated evidence packet: relevant requirements, constraints, current plan, alternatives, code snippets, diffs, command output, and open questions."
+      profile: profileSchema.nullish().describe(
+        "Named model profile to use for the rest of the conversation; omit or pass null for the default"
       )
-    }),
-    outputSchema: juniorToolResultSchema,
-    execute: async ({ question, context: suppliedContext }, { toolCallId } = {}) => {
-      if (typeof question !== "string" || !question.trim()) {
-        return failure(
-          "invalid_question",
-          "Advisor guidance is unavailable because the question was empty or invalid. Ask a focused advisor question before retrying."
-        );
-      }
-      const advisorQuestion = question.trim();
-      if (typeof suppliedContext !== "string" || !suppliedContext.trim()) {
-        return failure(
-          "invalid_context",
-          "Advisor guidance is unavailable because the curated context was empty or invalid. Include the relevant evidence and constraints before retrying."
-        );
-      }
-      const advisorContext = suppliedContext.trim();
-      if (!context.conversationId) {
-        return failure(
-          "missing_conversation_id",
-          "Advisor guidance is unavailable because this turn has no parent conversation id. Continue without assuming advisor history."
-        );
-      }
-      const conversationId = context.conversationId;
-      const childConversationId = advisorChildConversationId(conversationId);
-      const subagentInvocationId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : `advisor:${Date.now()}`;
-      const endSubagent = async (outcome, errorCode) => {
-        try {
-          await getAgentStepStore().append(conversationId, [
-            {
-              entry: {
-                type: "subagent_ended",
-                subagentInvocationId,
-                outcome,
-                ...errorCode ? { errorCode } : {}
-              },
-              createdAtMs: Date.now()
-            }
-          ]);
-        } catch (error) {
-          logWarn("advisor_subagent_ended_append_failed", spanContext, {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          });
-        }
-      };
-      try {
-        await conversationStore().ensureChildConversation({
-          conversationId: childConversationId,
-          parentConversationId: conversationId
-        });
-        await getAgentStepStore().append(conversationId, [
-          {
-            entry: {
-              type: "subagent_started",
-              subagentInvocationId,
-              subagentKind: "advisor",
-              modelId: context.config.modelId,
-              ...typeof toolCallId === "string" && toolCallId.length > 0 ? { parentToolCallId: toolCallId } : {},
-              childConversationId,
-              historyMode: "shared",
-              reasoningLevel: context.config.thinkingLevel
-            },
-            createdAtMs: Date.now()
-          }
-        ]);
-      } catch (error) {
-        logWarn("advisor_subagent_started_append_failed", spanContext, {
-          "exception.message": error instanceof Error ? error.message : String(error)
-        });
-      }
-      const conversationPrivacy = context.conversationPrivacy ?? "private";
-      const requestText = renderAdvisorRequest(advisorQuestion, advisorContext);
-      const advisorInputMessage = {
-        role: "user",
-        content: [{ type: "text", text: requestText }],
-        timestamp: Date.now()
+    }).strict(),
+    outputSchema: handoffResultSchema,
+    execute: async (input, options) => {
+      const profile = input.profile ?? defaultProfile;
+      await handoff.execute(profile, options.signal);
+      return {
+        ok: true,
+        status: "success",
+        model_profile: profile
       };
-      const advisorInputMessagesAttribute = serializeGenAiAttribute(
-        conversationPrivacy !== "public" ? [toGenAiMessageMetadata(advisorInputMessage)] : [toCanonicalInputMessage(advisorInputMessage)]
-      );
-      return await withSpan(
-        `invoke_agent ${context.config.modelId}`,
-        "gen_ai.invoke_agent",
-        spanContext,
-        async () => {
-          const requestMessage = {
-            role: "user",
-            content: [{ type: "text", text: requestText }],
-            timestamp: Date.now()
-          };
-          let advisorMessages;
-          try {
-            advisorMessages = await loadProjection({
-              conversationId: childConversationId
-            });
-          } catch {
-            setSpanStatus("error");
-            await endSubagent("error", "session_unavailable");
-            return failure(
-              "session_unavailable",
-              "Advisor guidance is unavailable because advisor history could not be loaded. Continue without assuming advisor history."
-            );
-          }
-          const apiKeyOverride = getPiGatewayApiKey();
-          const advisorAgent = new Agent({
-            ...apiKeyOverride ? { getApiKey: () => apiKeyOverride } : {},
-            initialState: {
-              systemPrompt: ADVISOR_SYSTEM_PROMPT,
-              model: resolveGatewayModel(context.config.modelId),
-              thinkingLevel: context.config.thinkingLevel,
-              tools: context.getTools()
-            },
-            sessionId: childConversationId,
-            streamFn: context.streamFn
-          });
-          advisorAgent.state.messages = advisorMessages;
-          const beforeMessageCount = advisorAgent.state.messages.length;
-          try {
-            await advisorAgent.prompt(requestMessage);
-          } catch {
-            setSpanStatus("error");
-            await endSubagent("error", "unavailable");
-            return failure(
-              "unavailable",
-              "Advisor guidance is unavailable. Continue without advisor guidance if the next step is clear from verified evidence."
-            );
-          }
-          const assistant = lastAssistantMessage(advisorAgent.state.messages);
-          const newAdvisorMessages = advisorAgent.state.messages.slice(beforeMessageCount);
-          const outputMessages = newAdvisorMessages.filter(isAssistantMessage);
-          const outputMessagesAttribute = serializeGenAiAttribute(
-            conversationPrivacy !== "public" ? outputMessages.map(toGenAiMessageMetadata) : outputMessages.map(toCanonicalOutputMessage)
-          );
-          setSpanAttributes({
-            ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
-            ...toGenAiMessagesTraceAttributes("app.ai.output", outputMessages),
-            ...extractGenAiUsageAttributes(...newAdvisorMessages)
-          });
-          if (!assistant || assistant.stopReason === "error" || assistant.stopReason === "aborted") {
-            setSpanStatus("error");
-            await endSubagent(
-              assistant?.stopReason === "aborted" ? "aborted" : "error",
-              "unavailable"
-            );
-            return failure(
-              "unavailable",
-              "Advisor guidance is unavailable. Continue without advisor guidance if the next step is clear from verified evidence."
-            );
-          }
-          const memo = extractAssistantText(assistant);
-          try {
-            await commitMessages({
-              conversationId: childConversationId,
-              messages: advisorAgent.state.messages
-            });
-          } catch {
-            setSpanStatus("error");
-            await endSubagent("error", "session_unavailable");
-            return failure(
-              "session_unavailable",
-              "Advisor guidance is unavailable because advisor history could not be saved. Retry the advisor call or continue without assuming advisor history."
-            );
-          }
-          await endSubagent("success");
-          setSpanStatus("ok");
-          return success(memo);
-        },
-        {
-          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-          "gen_ai.operation.name": "invoke_agent",
-          "gen_ai.request.model": context.config.modelId,
-          "gen_ai.output.type": "text",
-          "server.address": GEN_AI_SERVER_ADDRESS,
-          "server.port": GEN_AI_SERVER_PORT,
-          "app.conversation.privacy": conversationPrivacy,
-          ...toGenAiMessagesTraceAttributes("app.ai.input", [
-            advisorInputMessage
-          ]),
-          ...advisorInputMessagesAttribute ? { "gen_ai.input.messages": advisorInputMessagesAttribute } : {}
-        }
-      );
     }
   });
 }
@@ -9340,8 +9137,8 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks.toolOverrides?.imageGenerate
     );
   }
-  if (context.advisor) {
-    tools.advisor = createAdvisorTool(context.advisor);
+  if (context.handoff) {
+    tools.handoff = createHandoffTool(context.handoff);
   }
   if (canUseResourceEventSubscriptionTools(context)) {
     tools.subscribeToResourceEvents = createSubscribeToResourceEventsTool(context);
@@ -14539,7 +14336,6 @@ async function wireAgentTools(args) {
   const loadableSkills = args.availableSkills.filter(
     (skill) => skill.disableModelInvocation !== true || skill.name === args.invokedSkill?.name
   );
-  let advisorTools = [];
   const commonToolRuntimeContext = {
     conversationId: args.sessionConversationId,
     userText: args.userInput,
@@ -14565,16 +14361,7 @@ async function wireAgentTools(args) {
     mcpToolManager,
     sandbox,
     surface: args.surface,
-    advisor: {
-      config: botConfig.advisor,
-      conversationId: args.sessionConversationId,
-      conversationPrivacy: args.conversationPrivacy,
-      logContext: args.spanContext,
-      getTools: () => advisorTools,
-      streamFn: createTracedStreamFn({
-        conversationPrivacy: args.conversationPrivacy
-      })
-    }
+    ...args.requestHandoff ? { handoff: args.requestHandoff } : {}
   };
   const toolDestination = toolInvocationDestination(args.routing);
   let toolRuntimeContext;
@@ -14720,18 +14507,6 @@ async function wireAgentTools(args) {
     args.conversationPrivacy,
     args.observers.onToolResult
   );
-  advisorTools = createPiAgentTools(
-    createAdvisorToolDefinitions(tools),
-    args.skillSandbox,
-    args.spanContext,
-    args.observers.onStatus,
-    sandboxExecutor,
-    pluginAuth,
-    onToolCall,
-    pluginHooks,
-    args.conversationPrivacy,
-    args.observers.onToolResult
-  );
   return {
     activeMcpCatalogs,
     agentTools,
@@ -14770,7 +14545,7 @@ function createResumeState(args) {
     sessionId: args.sessionId,
     loadedSkillNames: args.getLoadedSkillNames(),
     logContext: args.logContext,
-    modelId: args.modelId,
+    modelId: args.getModelId(),
     ...args.getReasoningLevel() ? { reasoningLevel: args.getReasoningLevel() } : {},
     actor: args.actor,
     ...args.surface ? { surface: args.surface } : {}
@@ -14794,6 +14569,11 @@ function createResumeState(args) {
     setBeforeMessageCount(count) {
       beforeMessageCount = count;
     },
+    /** Adopt an already committed epoch replacement as every resume baseline. */
+    adoptCommittedBoundary(messages) {
+      latestSafeBoundaryMessages = [...messages];
+      resumeMessages = [...messages];
+    },
     captureResumeSnapshot(messages) {
       resumeMessages = [...messages];
     },
@@ -14938,6 +14718,319 @@ function createResumeState(args) {
   };
 }
 
+// src/chat/services/context-compaction.ts
+import {
+  estimateContextTokens,
+  estimateTokens
+} from "@earendil-works/pi-agent-core";
+var RETAINED_USER_MESSAGE_TOKENS = 2e4;
+var MAX_SUMMARY_INPUT_CHARS = 8e4;
+var MAX_VISIBLE_CONTEXT_CHARS = 2e4;
+var MAX_SUMMARY_CHARS = 6e3;
+var MAX_RENDERED_MESSAGE_CHARS = 4e3;
+var COMPACTION_SUMMARY_PREFIX = "Context compaction summary for future Junior turns:";
+var LEGACY_COMPACTION_SUMMARY_PREFIX = "Context handoff summary for future Junior turns:";
+var MODEL_HANDOFF_SUMMARY_PREFIX = "Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:";
+var OMITTED_OLDER_CONTEXT_NOTICE = "[older context omitted]";
+function textPart(value) {
+  if (value && typeof value === "object" && value.type === "text" && typeof value.text === "string") {
+    return value.text;
+  }
+  return void 0;
+}
+function messageText(message) {
+  const content = message.content;
+  const unwrapTask = message.role === "user";
+  const displayText = (text) => unwrapTask ? unwrapCurrentInstruction(text) ?? text : text;
+  if (!Array.isArray(content)) {
+    return typeof content === "string" ? displayText(content) : "";
+  }
+  return content.map(textPart).filter((text) => Boolean(text)).map(displayText).join("\n").trim();
+}
+function sanitizeText(text) {
+  return text.replace(
+    /<data_base64>[\s\S]*?<\/data_base64>/g,
+    "<data_base64>[omitted]</data_base64>"
+  ).replace(
+    /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi,
+    "[image data omitted]"
+  ).replaceAll("\0", " ").trim();
+}
+function truncateToTokenBudget(text, maxTokens) {
+  const maxChars = Math.max(0, maxTokens * 4);
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+function isCompactionSummary(text) {
+  const normalized = text.trimStart();
+  return normalized.startsWith(COMPACTION_SUMMARY_PREFIX) || normalized.startsWith(LEGACY_COMPACTION_SUMMARY_PREFIX) || normalized.startsWith(MODEL_HANDOFF_SUMMARY_PREFIX);
+}
+function isPayloadHeavy(text) {
+  return /<data_base64>[\s\S]*?<\/data_base64>|data:image\/[a-z0-9.+-]+;base64,/i.test(
+    text
+  );
+}
+function userMessage(text) {
+  return {
+    role: "user",
+    content: [{ type: "text", text }],
+    timestamp: Date.now()
+  };
+}
+function piMessageTimestamp(message) {
+  const timestamp = message.timestamp;
+  return typeof timestamp === "number" ? timestamp : Date.now();
+}
+function selectRetainedUserMessageEntries(messages, maxTokens = RETAINED_USER_MESSAGE_TOKENS) {
+  const selected = [];
+  let remaining = maxTokens;
+  for (let sourceIndex = messages.length - 1; sourceIndex >= 0; sourceIndex -= 1) {
+    const stripped = stripRuntimeTurnContext([messages[sourceIndex]]);
+    const message = stripped[0];
+    if (!message || message.role !== "user" || remaining <= 0) {
+      continue;
+    }
+    const text = sanitizeText(messageText(message));
+    if (!text || isCompactionSummary(text) || isPayloadHeavy(text)) {
+      continue;
+    }
+    const tokens = estimateTextTokens(text);
+    if (tokens <= remaining) {
+      selected.push({ message: userMessage(text), sourceIndex });
+      remaining -= tokens;
+      continue;
+    }
+    const truncated = truncateToTokenBudget(text, remaining);
+    if (truncated) {
+      selected.push({ message: userMessage(truncated), sourceIndex });
+    }
+    break;
+  }
+  return selected.reverse();
+}
+function renderMessageForSummary(message) {
+  const role = message.role;
+  if (typeof role !== "string") {
+    return void 0;
+  }
+  const text = sanitizeText(messageText(message));
+  if (!text) {
+    return void 0;
+  }
+  const trimmed = text.length > MAX_RENDERED_MESSAGE_CHARS ? `${text.slice(0, MAX_RENDERED_MESSAGE_CHARS).trimEnd()}...` : text;
+  return `[${role}] ${trimmed}`;
+}
+function keepTail(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const prefix = `${OMITTED_OLDER_CONTEXT_NOTICE}
+`;
+  return `${prefix}${text.slice(Math.max(0, text.length - maxChars + prefix.length))}`;
+}
+function renderSummaryInput(piMessages, conversationContext) {
+  const lines = [];
+  const visibleContext = conversationContext?.trim();
+  if (visibleContext) {
+    lines.push(
+      "<visible-thread-context>",
+      keepTail(visibleContext, MAX_VISIBLE_CONTEXT_CHARS),
+      "</visible-thread-context>",
+      ""
+    );
+  }
+  const renderedPiMessages = stripRuntimeTurnContext(piMessages).map(renderMessageForSummary).filter((line) => Boolean(line));
+  if (renderedPiMessages.length > 0) {
+    const piEnvelopeChars = "<pi-history>\n</pi-history>".length + 2;
+    const piHistory = keepTail(
+      renderedPiMessages.join("\n"),
+      Math.max(
+        1,
+        MAX_SUMMARY_INPUT_CHARS - lines.join("\n").length - piEnvelopeChars
+      )
+    );
+    lines.push("<pi-history>", piHistory, "</pi-history>");
+  }
+  return keepTail(lines.join("\n"), MAX_SUMMARY_INPUT_CHARS);
+}
+async function summarizeContext(args, deps) {
+  const source = renderSummaryInput(args.piMessages, args.conversationContext);
+  const result = await deps.completeText({
+    modelId: botConfig.fastModelId,
+    messageAttributeMode: "metadata",
+    temperature: 0,
+    signal: args.signal,
+    messages: [
+      {
+        role: "user",
+        content: [
+          "You are performing a CONTEXT CHECKPOINT COMPACTION for Junior.",
+          "Create a concise continuation summary for the agent that will continue this Slack thread.",
+          "",
+          "Include:",
+          "- Current outstanding asks",
+          "- Key decisions, completed work, and outcomes",
+          "- Durable constraints, user preferences, IDs, URLs, artifacts, canvas links, sandbox references, and auth state",
+          "- Clear next steps and unresolved blockers",
+          "",
+          "Do not invent details. Do not include raw secrets or credentials.",
+          "",
+          source
+        ].join("\n"),
+        timestamp: Date.now()
+      }
+    ],
+    metadata: {
+      modelId: botConfig.fastModelId,
+      threadId: args.metadata?.threadId ?? "",
+      channelId: args.metadata?.channelId ?? "",
+      actorId: args.metadata?.actorId ?? "",
+      runId: args.metadata?.runId ?? ""
+    }
+  });
+  const summary = result.text.trim();
+  if (!summary) {
+    throw new Error("Compaction summary was empty");
+  }
+  return summary.slice(0, MAX_SUMMARY_CHARS);
+}
+function estimateHistoryTokens(messages) {
+  const stripped = stripRuntimeTurnContext(messages);
+  const usageEstimate = estimateContextTokens(stripped).tokens;
+  const structuralEstimate = stripped.reduce(
+    (total, message) => total + estimateTokens(message),
+    0
+  );
+  return Math.max(usageEstimate, structuralEstimate);
+}
+function buildReplacementProvenance(args) {
+  return [
+    ...args.retained.map(
+      (entry) => args.sourceProvenance[entry.sourceIndex] ?? contextProvenance
+    ),
+    contextProvenance
+  ];
+}
+function loadCompactionSource(messages) {
+  if (messages.length > 0) {
+    return {
+      estimatedTokens: estimateHistoryTokens(messages),
+      messages
+    };
+  }
+  return { reason: "missing_context" };
+}
+async function maybeCompactWithDeps(args, deps) {
+  const source = loadCompactionSource(args.piMessages);
+  if ("reason" in source) {
+    return { compacted: false, reason: source.reason };
+  }
+  const triggerTokens = deps.autoCompactionTriggerTokens ?? getAgentContextCompactionTriggerTokens();
+  if (source.estimatedTokens <= triggerTokens) {
+    return { compacted: false, reason: "below_threshold" };
+  }
+  args.onCompactionStart?.();
+  let summary;
+  try {
+    summary = await summarizeContext(
+      {
+        conversationContext: args.conversationContext,
+        piMessages: source.messages,
+        metadata: args.metadata
+      },
+      deps
+    );
+  } catch (error) {
+    logWarn(
+      "context_compaction_summary_failed",
+      {
+        slackThreadId: args.metadata?.threadId,
+        slackUserId: args.metadata?.actorId,
+        slackChannelId: args.metadata?.channelId,
+        runId: args.metadata?.runId,
+        assistantUserName: botConfig.userName,
+        modelId: botConfig.fastModelId
+      },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Context compaction failed; continuing with prior history"
+    );
+    return { compacted: false, reason: "summary_failed" };
+  }
+  return await writeCompactedThreadContext(args, source.messages, summary, {
+    estimatedTokens: source.estimatedTokens,
+    triggerTokens
+  });
+}
+async function writeCompactedThreadContext(args, sourceMessages, summary, context) {
+  const stepStore = getAgentStepStore();
+  const sourceProjection = await loadConversationProjection({
+    conversationId: args.conversationId
+  });
+  const retained = selectRetainedUserMessageEntries(
+    trimTrailingAssistantMessages(sourceProjection.messages)
+  );
+  const replacement = [
+    ...retained.map((entry) => entry.message),
+    userMessage(`${COMPACTION_SUMMARY_PREFIX}
+${summary}`)
+  ];
+  const replacementProvenance = buildReplacementProvenance({
+    retained,
+    sourceProvenance: sourceProjection.provenance
+  });
+  await stepStore.startEpoch(args.conversationId, {
+    reason: "compaction",
+    modelProfile: sourceProjection.modelProfile,
+    modelId: modelIdForProfile(botConfig, sourceProjection.modelProfile),
+    messages: replacement.map((message, index) => ({
+      message,
+      createdAtMs: piMessageTimestamp(message),
+      provenance: replacementProvenance[index]
+    }))
+  });
+  updateConversationStats(args.conversation);
+  setSpanAttributes({
+    "app.compaction.input_messages": sourceMessages.length,
+    "app.compaction.retained_messages": replacement.length - 1,
+    "app.compaction.summary_chars": summary.length,
+    ...context.triggerTokens !== void 0 ? { "app.compaction.trigger_tokens": context.triggerTokens } : {},
+    "app.context_tokens_estimated": context.estimatedTokens
+  });
+  return {
+    compacted: true,
+    piMessages: replacement
+  };
+}
+function createContextCompactor(deps) {
+  return {
+    maybeCompact: async (args) => await maybeCompactWithDeps(args, deps)
+  };
+}
+async function compactContextForHandoff(args, deps) {
+  const summary = await summarizeContext(args, deps);
+  const message = userMessage(`${MODEL_HANDOFF_SUMMARY_PREFIX}
+${summary}`);
+  const messages = [message];
+  args.signal?.throwIfAborted();
+  await getAgentStepStore().startEpoch(args.conversationId, {
+    reason: "handoff",
+    modelProfile: args.target.modelProfile,
+    modelId: args.target.modelId,
+    messages: [
+      {
+        message,
+        createdAtMs: piMessageTimestamp(message),
+        provenance: contextProvenance
+      }
+    ]
+  });
+  return messages;
+}
+
 // src/chat/agent/index.ts
 var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
 function waitForAbortSettlement(promise, timeoutMs) {
@@ -15006,7 +15099,10 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
   let connectedMcpProviders = /* @__PURE__ */ new Set();
   let canRecordMcpProviders = false;
   let turnUsage;
+  let handoffPhaseUsage;
   let thinkingSelection;
+  let activeModelProfile = STANDARD_MODEL_PROFILE;
+  let activeModelId = modelIdForProfile(botConfig, activeModelProfile);
   const actor = actorFromRouting(routing);
   const surface = surfaceFromRouting(routing);
   const runSource = routing.source;
@@ -15022,8 +15118,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     channelId: routing.correlation?.channelId,
     runId: routing.correlation?.runId,
     ...credentialActorLogContext,
-    assistantUserName: botConfig.userName,
-    modelId: botConfig.modelId
+    assistantUserName: botConfig.userName
   };
   const { conversationId: sessionConversationId, sessionId } = getSessionIdentifiers(routing);
   const recordConnectedMcpProvider = async (provider) => {
@@ -15049,6 +15144,14 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     sandboxDependencyProfileHash: lastKnownSandboxDependencyProfileHash
   });
   try {
+    if (sessionConversationId) {
+      const projection = await openConversationProjection({
+        conversationId: sessionConversationId,
+        modelId: activeModelId
+      });
+      activeModelProfile = projection.modelProfile;
+      activeModelId = modelIdForProfile(botConfig, activeModelProfile);
+    }
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = {
       conversationId: sessionConversationId,
@@ -15058,7 +15161,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       runId: routing.correlation?.runId,
       ...credentialActorLogContext,
       assistantUserName: botConfig.userName,
-      modelId: botConfig.modelId
+      modelId: activeModelId
     };
     const availableSkills = await discoverRunSkills({
       skillDirs: policy.skillDirs,
@@ -15097,10 +15200,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       currentSliceId,
       existingSessionRecord
     } = await restoreSessionRecord(routing);
-    const committedInstructionProvenance = existingSessionRecord?.piMessageProvenance ? [
-      ...existingSessionRecord.piMessageProvenance,
+    const committedInstructionProvenance = [
+      ...existingSessionRecord?.piMessageProvenance ?? [],
+      ...(existingSessionRecord?.actors ?? []).map(instructionProvenanceFor),
       ...resumedFromSessionRecord ? [] : [instructionProvenanceFor(actor)]
-    ] : [instructionProvenanceFor(actor)];
+    ];
     const runActors = () => instructionActors(committedInstructionProvenance);
     canRecordMcpProviders = Boolean(
       sessionRecordState.canUseTurnSession && sessionConversationId && sessionId
@@ -15112,7 +15216,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       getLoadedSkillNames: () => loadedSkillNamesForResume,
       getReasoningLevel: () => thinkingSelection?.thinkingLevel,
       logContext: sessionRecordLogContext,
-      modelId: botConfig.modelId,
+      getModelId: () => activeModelId,
       recordActiveMcpProviders,
       actor,
       runSource,
@@ -15181,7 +15285,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       messageText: userInput
     });
     setSpanAttributes({
-      "gen_ai.request.model": botConfig.modelId,
+      "gen_ai.request.model": activeModelId,
       "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel,
       "app.ai.thinking_level_reason": thinkingSelection.reason,
       ...thinkingSelection.confidence !== void 0 ? {
@@ -15192,7 +15296,55 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     const artifactStatePatch = {};
     const toolCalls = [];
     let agent;
+    let pendingHandoff;
     const currentAgentMessages = () => agent ? [...agent.state.messages] : [];
+    const handoffProfiles = [
+      DEFAULT_HANDOFF_MODEL_PROFILE,
+      ...Object.keys(botConfig.modelProfiles).filter((profile) => profile !== DEFAULT_HANDOFF_MODEL_PROFILE).sort()
+    ];
+    const requestHandoff = activeModelProfile === STANDARD_MODEL_PROFILE && sessionConversationId ? {
+      profiles: handoffProfiles,
+      execute: async (profile, signal2) => {
+        const sourceMessages = [...agent.state.messages];
+        const runtimeContext = retainRuntimeTurnContext(sourceMessages);
+        const standardPhaseUsage = extractGenAiUsageSummary(
+          ...sourceMessages.slice(runResume.beforeMessageCount).filter(isAssistantMessage)
+        );
+        const phaseUsage = hasAgentTurnUsage(standardPhaseUsage) ? standardPhaseUsage : void 0;
+        const target = {
+          modelId: modelIdForProfile(botConfig, profile),
+          modelProfile: profile
+        };
+        const handoffModel = resolveGatewayModel(target.modelId);
+        const handoffThinkingLevel = toAgentThinkingLevel(
+          thinkingSelection.thinkingLevel
+        );
+        const handoffMessages = await compactContextForHandoff(
+          {
+            conversationContext: input.conversationContext,
+            conversationId: sessionConversationId,
+            piMessages: sourceMessages,
+            signal: signal2,
+            target,
+            metadata: {
+              threadId: routing.correlation?.threadId,
+              channelId: routing.correlation?.channelId,
+              actorId: routing.correlation?.actorId,
+              runId: routing.correlation?.runId
+            }
+          },
+          { completeText }
+        );
+        handoffPhaseUsage = phaseUsage;
+        pendingHandoff = {
+          messages: [...handoffMessages, ...runtimeContext],
+          model: handoffModel,
+          thinkingLevel: handoffThinkingLevel
+        };
+        activeModelProfile = profile;
+        activeModelId = target.modelId;
+      }
+    } : void 0;
     setTags({
       conversationId: spanContext.conversationId,
       slackThreadId: routing.correlation?.threadId,
@@ -15201,7 +15353,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       runId: routing.correlation?.runId,
       ...credentialActorLogContext,
       assistantUserName: botConfig.userName,
-      modelId: botConfig.modelId
+      modelId: activeModelId
     });
     const wiring = await wireAgentTools({
       abortAgent: () => agent?.abort(),
@@ -15225,6 +15377,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       preAgentPromptMessages,
       priorPiMessages,
       recordConnectedMcpProvider,
+      requestHandoff,
       resume: runResume,
       routing,
       sessionConversationId,
@@ -15240,6 +15393,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     mcpToolManager = wiring.mcpToolManager;
     const sandboxExecutor = wiring.sandboxExecutor;
     const getPendingAuthPause = wiring.getPendingAuthPause;
+    const toolsAfterHandoff = wiring.agentTools.filter(
+      (tool) => tool.name !== HANDOFF_TOOL_NAME
+    );
     const {
       baseInstructions,
       inputMessages,
@@ -15267,6 +15423,38 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     });
     let hasEmittedText = false;
     let needsSeparator = false;
+    let bufferedStandardText = "";
+    let bufferedStandardMessageStart = false;
+    const startAssistantMessage = () => {
+      Promise.resolve(observers.onAssistantMessageStart?.()).catch((error) => {
+        logWarn(
+          "streaming_message_start_error",
+          {},
+          {
+            "exception.message": error instanceof Error ? error.message : String(error)
+          },
+          "Failed to deliver assistant message start to stream coordinator"
+        );
+      });
+      if (hasEmittedText) {
+        needsSeparator = true;
+      }
+    };
+    const deliverText = (deltaText) => {
+      const text = needsSeparator ? "\n\n" + deltaText : deltaText;
+      needsSeparator = false;
+      hasEmittedText = true;
+      Promise.resolve(observers.onTextDelta?.(text)).catch((error) => {
+        logWarn(
+          "streaming_text_delta_error",
+          {},
+          {
+            "exception.message": error instanceof Error ? error.message : String(error)
+          },
+          "Failed to deliver text delta to stream"
+        );
+      });
+    };
     const drainSteeringMessages = async () => {
       if (!durability.drainSteeringMessages || !sessionRecordState.canUseTurnSession || !sessionConversationId || !sessionId) {
         return;
@@ -15315,18 +15503,60 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       }
     };
     const apiKeyOverride = getPiGatewayApiKey();
-    agent = new Agent2({
+    agent = new Agent({
       ...apiKeyOverride ? { getApiKey: () => apiKeyOverride } : {},
       streamFn: createTracedStreamFn({ conversationPrivacy }),
       steeringMode: "all",
+      beforeToolCall: async ({ assistantMessage }) => {
+        const toolCalls2 = assistantMessage.content.filter(
+          (part) => part.type === "toolCall"
+        );
+        const containsHandoff = toolCalls2.some(
+          (call) => call.name === HANDOFF_TOOL_NAME
+        );
+        if (containsHandoff && toolCalls2.length !== 1) {
+          return {
+            block: true,
+            reason: "handoff must be the only tool call in its assistant message; reissue it alone"
+          };
+        }
+        return void 0;
+      },
       prepareNextTurn: async () => {
+        let update;
+        if (pendingHandoff) {
+          const { messages, model, thinkingLevel } = pendingHandoff;
+          const replacement = [...messages];
+          pendingHandoff = void 0;
+          agent.state.messages = replacement;
+          agent.state.model = model;
+          agent.state.thinkingLevel = thinkingLevel;
+          agent.state.tools = toolsAfterHandoff;
+          runResume.setBeforeMessageCount(replacement.length);
+          runResume.setTurnStartMessageIndex(0);
+          runResume.adoptCommittedBoundary(replacement);
+          setSpanAttributes({
+            "gen_ai.request.model": activeModelId,
+            "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel,
+            "app.ai.model_profile": activeModelProfile
+          });
+          update = {
+            context: {
+              systemPrompt: baseInstructions,
+              messages: replacement,
+              tools: toolsAfterHandoff
+            },
+            model,
+            thinkingLevel
+          };
+        }
         await drainSteeringMessages();
         runResume.yieldAtSafeBoundaryIfDue(currentAgentMessages());
-        return void 0;
+        return update;
       },
       initialState: {
         systemPrompt: baseInstructions,
-        model: resolveGatewayModel(botConfig.modelId),
+        model: resolveGatewayModel(activeModelId),
         thinkingLevel: toAgentThinkingLevel(thinkingSelection.thinkingLevel),
         tools: wiring.agentTools
       }
@@ -15336,43 +15566,46 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         return recordParentToolExecutionStart(event);
       }
       if (event.type === "turn_end" && event.toolResults.length > 0) {
+        if (pendingHandoff) {
+          return;
+        }
         return runResume.persistSafeBoundary([...agent.state.messages]).then(() => void 0);
       }
       if (event.type === "message_start") {
-        Promise.resolve(observers.onAssistantMessageStart?.()).catch(
-          (error) => {
-            logWarn(
-              "streaming_message_start_error",
-              {},
-              {
-                "exception.message": error instanceof Error ? error.message : String(error)
-              },
-              "Failed to deliver assistant message start to stream coordinator"
-            );
-          }
+        if (activeModelProfile === STANDARD_MODEL_PROFILE && requestHandoff) {
+          bufferedStandardMessageStart = true;
+          bufferedStandardText = "";
+        } else {
+          startAssistantMessage();
+        }
+        return;
+      }
+      if (event.type === "message_end" && isAssistantMessage(event.message)) {
+        if (!bufferedStandardMessageStart) {
+          return;
+        }
+        const containsHandoff = event.message.content.some(
+          (part) => part.type === "toolCall" && part.name === HANDOFF_TOOL_NAME
         );
-        if (hasEmittedText) {
-          needsSeparator = true;
+        if (!containsHandoff) {
+          startAssistantMessage();
+          if (bufferedStandardText) {
+            deliverText(bufferedStandardText);
+          }
         }
+        bufferedStandardMessageStart = false;
+        bufferedStandardText = "";
         return;
       }
       if (event.type !== "message_update") return;
       if (event.assistantMessageEvent.type !== "text_delta") return;
       const deltaText = event.assistantMessageEvent.delta;
       if (!deltaText) return;
-      const text = needsSeparator ? "\n\n" + deltaText : deltaText;
-      needsSeparator = false;
-      hasEmittedText = true;
-      Promise.resolve(observers.onTextDelta?.(text)).catch((error) => {
-        logWarn(
-          "streaming_text_delta_error",
-          {},
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to deliver text delta to stream"
-        );
-      });
+      if (bufferedStandardMessageStart) {
+        bufferedStandardText += deltaText;
+      } else {
+        deliverText(deltaText);
+      }
     });
     let newMessages = [];
     try {
@@ -15389,7 +15622,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         runResume.setTurnStartMessageIndex(agent.state.messages.length);
       }
       await withSpan(
-        `invoke_agent ${botConfig.modelId}`,
+        `invoke_agent ${activeModelId}`,
         "gen_ai.invoke_agent",
         spanContext,
         async () => {
@@ -15454,7 +15687,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
                   {
                     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
                     "gen_ai.operation.name": "invoke_agent",
-                    "gen_ai.request.model": botConfig.modelId,
+                    "gen_ai.request.model": activeModelId,
                     ...thinkingSelection ? {
                       "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel
                     } : {},
@@ -15519,7 +15752,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
               ...outputMessages
             );
             const currentUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
-            turnUsage = addAgentTurnUsage(retryUsage, currentUsage);
+            const currentPhaseUsage = addAgentTurnUsage(
+              retryUsage,
+              currentUsage
+            );
+            turnUsage = addAgentTurnUsage(handoffPhaseUsage, currentPhaseUsage);
             setSpanAttributes({
               ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
               ...toGenAiMessagesTraceAttributes(
@@ -15543,7 +15780,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
             if (!providerRetry) {
               break;
             }
-            retryUsage = turnUsage;
+            retryUsage = currentPhaseUsage;
             agent.state.messages = providerRetry.messages;
             await runResume.persistSafeBoundary(providerRetry.messages);
             logWarn(
@@ -15560,7 +15797,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "invoke_agent",
-          "gen_ai.request.model": botConfig.modelId,
+          "gen_ai.request.model": activeModelId,
           "gen_ai.output.type": "text",
           "server.address": GEN_AI_SERVER_ADDRESS,
           "server.port": GEN_AI_SERVER_PORT,
@@ -15596,7 +15833,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         usage: turnUsage,
         thinkingSelection,
         correlation: routing.correlation,
-        assistantUserName: botConfig.userName
+        assistantUserName: botConfig.userName,
+        modelId: activeModelId
       })
     };
   } catch (error) {
@@ -15609,6 +15847,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         return outcome;
       }
     }
+    if (error instanceof ModelProfileNotConfiguredError) {
+      throw error;
+    }
     if (isProviderRetryError(error)) {
       throw error;
     }
@@ -15631,7 +15872,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         runId: routing.correlation?.runId,
         ...credentialActorLogContext,
         assistantUserName: botConfig.userName,
-        modelId: botConfig.modelId
+        modelId: activeModelId
       },
       {},
       "executeAgentRun failed"
@@ -15644,7 +15885,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         ...getSandboxMetadata(),
         diagnostics: {
           outcome: "provider_error",
-          modelId: botConfig.modelId,
+          modelId: activeModelId,
           assistantMessageCount: 0,
           ...thinkingSelection ? {
             thinkingLevel: thinkingSelection.thinkingLevel
@@ -15731,6 +15972,7 @@ export {
   finalizeMcpAuthorization,
   resolvePluginOAuthAccount,
   executeCredentialedEgressRequest,
+  createContextCompactor,
   executeAgentRun,
   createAgentRunner
 };