@opengeni/worker-bundle 1.0.0-canary.1 → 1.0.0

package/src/activities/agent-turn/compaction-prep.ts

@@ -4,11 +4,17 @@ import {
   appendSessionInstructions,
   appendWorkspaceGovernance,
   appendWorkspaceMemory,
+  agentPromptResourcesFor,
   composeAgentInstructions,
+  inspectPersistentAgentInstructions,
   requestRemoteCompactionV2,
-  serializedToolsForRemoteCompaction,
-  EmptyCompactionSummaryError,
-  SUMMARY_BUFFER_TOKENS,
+  preparedCompactionRequest,
+  queuePreparedCompaction,
+  compactionThresholdTokens,
+  CompactionNeededError,
+  compactionProviderRejection,
+  estimateSerializedValueTokens,
+  compactionSummaryOutputTokens,
   type ModelResponseUsage,
 } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
@@ -31,7 +37,7 @@ import { type SessionEvent } from "@opengeni/contracts";
 import { acceptsPromptCacheKeyForTurn } from "./codex";
 import {
   safeErrorDiagnostic,
-  compactionFailureReasonFromError,
+  compactionFailureTurnEventPayload,
   isCompactionSummaryFailure,
   shouldRecoverCompactionProviderFailure,
 } from "./errors";
@@ -53,10 +59,7 @@ import type {
 } from "./turn-context";
 
 export type RemoteCompactionPrefix = {
-  tools: Awaited<ReturnType<typeof serializedToolsForRemoteCompaction>>;
-  instructions: string;
-  toolsReady: boolean;
-  agent: Parameters<typeof serializedToolsForRemoteCompaction>[0] | null;
+  agent: ReturnType<ActivityServices["runtime"]["buildAgent"]> | null;
 };
 
 export type CompactionPrepDeps = {
@@ -85,6 +88,7 @@ export type CompactionPrepDeps = {
   turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
   resolvedModel: GovernanceModelOk["resolvedModel"];
   workspaceAgentInstructions: GovernanceModelOk["workspaceAgentInstructions"];
+  workspaceAgentIdentity: GovernanceModelOk["workspaceAgentIdentity"];
   workspaceGovernance: GovernanceModelOk["workspaceGovernance"];
   structuredWorkspacePolicyActive: GovernanceModelOk["structuredWorkspacePolicyActive"];
   workspaceMemory: GovernanceModelOk["workspaceMemory"];
@@ -130,6 +134,59 @@ export type PostAgentCompactionOutcome =
   | { exit: RunAgentTurnResult }
   | { ok: PostAgentCompactionOk };
 
+/**
+ * System instructions for the standalone (chat-provider) compaction request.
+ * A session with an agent configuration uses the same modular composer and
+ * module selection as its turns; a legacy session keeps the historical
+ * persona + CORE + governance + session + memory string byte-for-byte.
+ */
+export function standaloneCompactionInstructions(input: {
+  settings: Settings;
+  session: Pick<ClaimTurnOk["session"], "agent" | "instructions" | "resources">;
+  workspaceAgentInstructions: string | null | undefined;
+  workspaceAgentIdentity: string | null;
+  workspaceGovernance: string | null | undefined;
+  structuredWorkspacePolicyActive: boolean;
+  workspaceMemory: string | null | undefined;
+  rig: { name: string; version: number } | undefined;
+}): string {
+  if (input.session.agent) {
+    return inspectPersistentAgentInstructions(input.settings, {
+      agentConfig: input.session.agent,
+      ...(input.workspaceAgentIdentity
+        ? { workspaceAgentIdentity: input.workspaceAgentIdentity }
+        : {}),
+      ...(input.workspaceGovernance ? { workspaceGovernance: input.workspaceGovernance } : {}),
+      ...(input.workspaceMemory ? { workspaceMemory: input.workspaceMemory } : {}),
+      ...(input.session.instructions ? { sessionInstructions: input.session.instructions } : {}),
+      ...(input.rig ? { rig: input.rig } : {}),
+      // Session-level facts only: per-turn attachments do not apply to a
+      // standalone compaction request.
+      agentPromptResources: agentPromptResourcesFor(
+        input.settings,
+        input.session.resources.filter((resource) => resource.kind !== "file"),
+        input.rig ? { rig: input.rig } : {},
+      ),
+    }).composed;
+  }
+  return appendWorkspaceMemory(
+    appendSessionInstructions(
+      appendWorkspaceGovernance(
+        composeAgentInstructions(
+          input.structuredWorkspacePolicyActive
+            ? input.settings.agentInstructionsTemplate
+            : (input.workspaceAgentInstructions ?? input.settings.agentInstructionsTemplate),
+          undefined,
+          input.rig,
+        ),
+        input.workspaceGovernance ?? undefined,
+      ),
+      input.session.instructions ?? undefined,
+    ),
+    input.workspaceMemory ?? undefined,
+  );
+}
+
 export async function prepareCompaction(deps: CompactionPrepDeps): Promise<CompactionPrepOutcome> {
   const {
     input,
@@ -154,6 +211,7 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     turnExecutionPolicy,
     resolvedModel,
     workspaceAgentInstructions,
+    workspaceAgentIdentity,
     workspaceGovernance,
     structuredWorkspacePolicyActive,
     workspaceMemory,
@@ -166,11 +224,15 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
   } = deps;
 
   const remotePrefix: RemoteCompactionPrefix = {
-    tools: [],
-    instructions: "",
-    toolsReady: false,
     agent: null,
   };
+  const portableResponsesNeedsAgentPrefix =
+    resolvedModel?.provider.api === "responses" &&
+    !(billingState.isCodexTurn && session.codexCompactionMode === "remote_v2");
+  const preparedPortableRequest = () => {
+    if (!remotePrefix.agent) throw new Error("Compaction agent is unavailable");
+    return preparedCompactionRequest(remotePrefix.agent);
+  };
 
   const promptCacheKey = acceptsPromptCacheKeyForTurn(resolvedModel) ? input.sessionId : undefined;
   const compactionUsageState = createCompactionModelUsageEventState(claimedModelUsageSourceKeys);
@@ -203,8 +265,8 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
       contextContributions: eventing.companyBrainContextContributions,
     });
   };
-  const compactionSummarizerFor = (systemInstructions?: string) =>
-    resolvedModel
+  const compactionSummarizerFor = (systemInstructions?: string): CompactionSummarizer => {
+    const summarize: CompactionSummarizer = resolvedModel
       ? (s: Settings, m: Array<Record<string, unknown>>) =>
           withProviderRequestContext(() =>
             summarizeContextForCompaction(s, m, {
@@ -212,20 +274,37 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
               provider: resolvedModel.provider,
               api: resolvedModel.provider.api,
               model: turnExecutionPolicy.upstreamModelId,
-              maxOutputTokens: SUMMARY_BUFFER_TOKENS,
+              maxOutputTokens: compactionSummaryOutputTokens(s.contextWindowTokens),
+              ...(cancellationSignal ? { signal: cancellationSignal } : {}),
               onUsage: recordCompactionUsage,
               ...(systemInstructions ? { systemInstructions } : {}),
               ...(promptCacheKey ? { promptCacheKey } : {}),
+              ...(portableResponsesNeedsAgentPrefix
+                ? { preparedRequest: preparedPortableRequest() }
+                : {}),
             }),
           )
       : (s: Settings, m: Array<Record<string, unknown>>) =>
           summarizeContextForCompaction(s, m, {
             model: turnExecutionPolicy.upstreamModelId,
-            maxOutputTokens: SUMMARY_BUFFER_TOKENS,
+            maxOutputTokens: compactionSummaryOutputTokens(s.contextWindowTokens),
+            ...(cancellationSignal ? { signal: cancellationSignal } : {}),
             onUsage: recordCompactionUsage,
             ...(systemInstructions ? { systemInstructions } : {}),
             ...(promptCacheKey ? { promptCacheKey } : {}),
           });
+    summarize.estimatePrefixTokens = () => {
+      if (resolvedModel?.provider.api === "chat") {
+        return estimateSerializedValueTokens(systemInstructions ?? "");
+      }
+      const prepared = portableResponsesNeedsAgentPrefix ? preparedPortableRequest() : null;
+      return (
+        estimateSerializedValueTokens(prepared?.systemInstructions ?? systemInstructions ?? "") +
+        (prepared ? estimateSerializedValueTokens(prepared.tools) : 0)
+      );
+    };
+    return summarize;
+  };
   // Prompt-cache prefix for remote_v2 MUST match ordinary turns:
   // tools → instructions → history. Filled after buildAgent for every
   // compact path (including operator /compact, which now builds the agent
@@ -234,45 +313,16 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     resolvedModel && billingState.isCodexTurn
       ? (s: Settings, m: Array<Record<string, unknown>>) =>
           withCodexRemoteCompaction(async () => {
-            // Lazily serialize tools here so EmptyCompactionSummaryError is
-            // thrown inside the compaction try/settlement handlers, not as a
-            // raw activity failure before maybeCompactContext runs.
-            if (!remotePrefix.instructions.trim()) {
-              throw new EmptyCompactionSummaryError({
-                stage: "remote_v2_instructions",
-                reason: "agent_missing_system_instructions",
-              });
-            }
-            if (!remotePrefix.toolsReady) {
-              if (!remotePrefix.agent) {
-                throw new EmptyCompactionSummaryError({
-                  stage: "remote_v2_tools",
-                  reason: "agent_missing_for_tools",
-                });
-              }
-              try {
-                remotePrefix.tools = await serializedToolsForRemoteCompaction(remotePrefix.agent);
-              } catch (error) {
-                // Tool schemas sit before instructions in the cache prefix.
-                // Failing open to [] would reintroduce a massive pre-compact
-                // cache bust — fail closed so we never send a tools mismatch
-                // on purpose.
-                throw new EmptyCompactionSummaryError({
-                  stage: "remote_v2_tools",
-                  reason: "serialize_tools_failed",
-                  error: String(error),
-                });
-              }
-              remotePrefix.toolsReady = true;
-            }
+            if (!remotePrefix.agent) throw new Error("Compaction agent is unavailable");
+            const preparedRequest = preparedCompactionRequest(remotePrefix.agent);
             return requestRemoteCompactionV2(s, m, {
               client: resolvedModel.client,
               provider: resolvedModel.provider,
               model: turnExecutionPolicy.upstreamModelId,
-              systemInstructions: remotePrefix.instructions,
+              preparedRequest,
+              captureAgent: remotePrefix.agent,
+              signal: cancellationSignal,
               onUsage: recordCompactionUsage,
-              tools: remotePrefix.tools,
-              ...(promptCacheKey ? { promptCacheKey } : {}),
             });
           })
       : undefined;
@@ -297,13 +347,9 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     ...(remoteCompactionRequester ? { requestRemoteCompactionV2: remoteCompactionRequester } : {}),
   } as const;
 
-  // Operator /compact:
-  // - portable (incl. Codex portable): early maintenance path — no
-  //   prepareTools/sandbox; summarizer only needs composed instructions.
-  // - remote_v2: fall through to prepareTools/buildAgent so the compact
-  //   request reuses the ordinary tools→instructions cache prefix, then
-  //   settle without inference. (Requester is also wired for Codex portable
-  //   turns but unused there — gate on the frozen session mode.)
+  // Responses compaction, portable or remote, prepares the ordinary agent
+  // request first so tool schemas and instructions match the warm cache prefix.
+  // Chat providers keep the standalone portable maintenance path.
   const compactionOnlyTurn = turn.source === "compaction";
   const remoteV2CompactionNeedsAgentPrefix =
     Boolean(remoteCompactionRequester) && session.codexCompactionMode === "remote_v2";
@@ -340,23 +386,21 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     control.activityStatus = "idle";
     return claimedResult({ status: "idle" });
   };
-  if (compactionOnlyTurn && !remoteV2CompactionNeedsAgentPrefix) {
-    const compactionInstructions = appendWorkspaceMemory(
-      appendSessionInstructions(
-        appendWorkspaceGovernance(
-          composeAgentInstructions(
-            structuredWorkspacePolicyActive
-              ? eventing.modelRunSettings.agentInstructionsTemplate
-              : (workspaceAgentInstructions ?? eventing.modelRunSettings.agentInstructionsTemplate),
-            undefined,
-            rigVersion && rigName ? { name: rigName, version: rigVersion.version } : undefined,
-          ),
-          workspaceGovernance ?? undefined,
-        ),
-        session.instructions ?? undefined,
-      ),
-      workspaceMemory ?? undefined,
-    );
+  if (
+    compactionOnlyTurn &&
+    !remoteV2CompactionNeedsAgentPrefix &&
+    !portableResponsesNeedsAgentPrefix
+  ) {
+    const compactionInstructions = standaloneCompactionInstructions({
+      settings: eventing.modelRunSettings,
+      session,
+      workspaceAgentInstructions,
+      workspaceAgentIdentity,
+      workspaceGovernance,
+      structuredWorkspacePolicyActive,
+      workspaceMemory,
+      rig: rigVersion && rigName ? { name: rigName, version: rigVersion.version } : undefined,
+    });
     const requested = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     let outcome: Awaited<ReturnType<typeof maybeCompactContext>> | null = null;
     if (requested) {
@@ -409,22 +453,16 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
           {
             clearRequestedCompaction: true,
             publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection(error),
           },
         );
         if (!isCompactionSummaryFailure(error)) throw error;
-        const errorMessage = String(compactionFailureReasonFromError(error));
         if (
           !(await eventing.settle!({
             events: [
               {
                 type: "turn.failed",
-                payload: {
-                  error: errorMessage,
-                  code: "context_compaction_failed",
-                  retryable: false,
-                  recovery: "user_message",
-                  compacted: false,
-                },
+                payload: compactionFailureTurnEventPayload(error),
               },
               {
                 type: "session.status.changed",
@@ -504,6 +542,7 @@ export async function runPostAgentCompaction(
     claimedResult,
     turn,
     session,
+    resolvedModel,
     remotePrefix,
     remoteCompactionRequester,
     publishCompactionLiveEvents,
@@ -518,20 +557,36 @@ export async function runPostAgentCompaction(
   } = deps;
 
   const agentInstructions = typeof agent.instructions === "string" ? agent.instructions : "";
+  const preparedPortable =
+    resolvedModel?.provider.api === "responses" &&
+    !(remoteCompactionRequester && session.codexCompactionMode === "remote_v2");
   const compactSummarizer = compactionSummarizerFor(
     agentInstructions.trim() ? agentInstructions : undefined,
   );
-  if (remoteCompactionRequester) {
-    // Exact byte match with the ordinary turn prefix (CLI base_instructions).
-    // Tools serialize lazily inside the requester so setup failures settle as
-    // compaction failures rather than raw activity crashes.
-    remotePrefix.instructions = agentInstructions;
+  if (remoteCompactionRequester || preparedPortable) {
+    // The prefix is captured only after this agent passes normal SDK preparation.
     remotePrefix.agent = agent;
   }
 
   if (compactionOnlyTurn) {
     const requested = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     let outcome: Awaited<ReturnType<typeof maybeCompactContext>> | null = null;
+    if (
+      requested &&
+      (preparedPortable ||
+        (remoteCompactionRequester && session.codexCompactionMode === "remote_v2"))
+    ) {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: "operator",
+          signalSource: "operator",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens: compactionThresholdTokens(eventing.modelRunSettings),
+        }),
+      );
+      return { ok: { compactSummarizer } };
+    }
     if (requested) {
       try {
         outcome = await waitForTurnOperation(
@@ -579,22 +634,16 @@ export async function runPostAgentCompaction(
           {
             clearRequestedCompaction: true,
             publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection(error),
           },
         );
         if (!isCompactionSummaryFailure(error)) throw error;
-        const errorMessage = String(compactionFailureReasonFromError(error));
         if (
           !(await eventing.settle!({
             events: [
               {
                 type: "turn.failed",
-                payload: {
-                  error: errorMessage,
-                  code: "context_compaction_failed",
-                  retryable: false,
-                  recovery: "user_message",
-                  compacted: false,
-                },
+                payload: compactionFailureTurnEventPayload(error),
               },
               {
                 type: "session.status.changed",
@@ -645,6 +694,31 @@ export async function runPostAgentCompaction(
     return { exit: claimedResult({ status: "idle" }) };
   }
 
+  if (
+    preparedPortable ||
+    (remoteCompactionRequester && session.codexCompactionMode === "remote_v2")
+  ) {
+    const forced = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
+    const thresholdTokens = compactionThresholdTokens(eventing.modelRunSettings);
+    if (
+      forced ||
+      ((attempt.triggerType === "user.message" ||
+        attempt.triggerType === "system.update.delivered") &&
+        (session.lastInputTokens ?? 0) >= thresholdTokens)
+    ) {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: forced ? "operator" : "threshold",
+          signalSource: forced ? "operator" : "provider",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens,
+        }),
+      );
+    }
+    return { ok: { compactSummarizer } };
+  }
+
   // Pre-turn durable context compaction. When the single Codex-parity
   // threshold is crossed, this summarizes active history and rebuilds active
   // history as [user messages..., summary] BEFORE the model input is read.
@@ -731,12 +805,12 @@ export async function runPostAgentCompaction(
         {
           clearRequestedCompaction: forced,
           publishLiveEvents: publishCompactionLiveEvents,
+          providerRejection: compactionProviderRejection(compactError),
         },
       );
       if (!isCompactionSummaryFailure(compactError)) throw compactError;
       const deferredSteer = await settleDeferredSteerAfterCompaction();
       if (deferredSteer) return { exit: deferredSteer };
-      const errorMessage = String(compactionFailureReasonFromError(compactError));
       observability.error("context compaction failed", {
         sessionId: input.sessionId,
         turnId: attempt.turnId,
@@ -747,13 +821,7 @@ export async function runPostAgentCompaction(
           events: [
             {
               type: "turn.failed",
-              payload: {
-                error: errorMessage,
-                code: "context_compaction_failed",
-                retryable: false,
-                recovery: "user_message",
-                compacted: false,
-              },
+              payload: compactionFailureTurnEventPayload(compactError),
             },
             { type: "session.status.changed", payload: { status: "idle" } },
           ],