Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🧱 refactor: Make Activity Phase Anchor Construction Exhaustive (#14805)

Danny Avila619ed2f1fbe7
diff --git a/packages/api/src/agents/activityPhases/runtime.spec.ts b/packages/api/src/agents/activityPhases/runtime.spec.ts
index e809f922b7..f9291240d9 100644
--- a/packages/api/src/agents/activityPhases/runtime.spec.ts
+++ b/packages/api/src/agents/activityPhases/runtime.spec.ts
@@ -1547,6 +1547,63 @@ describe('createActivityPhaseWiring', () => {
});
});
+ /** Folding is a memory bound, not a data loss: whatever an anchor pair
+ * represented before the merge it must still represent after. Runs are
+ * sized to force many merges past the 77-activity tracked window. */
+ it.each([
+ { total: 100, failEvery: 0, agents: 1 },
+ { total: 150, failEvery: 3, agents: 4 },
+ { total: 220, failEvery: 7, agents: 220 },
+ ])('conserves counts and agents while folding %o', async ({ total, failEvery, agents }) => {
+ const parts: LooseContentPart[] = [];
+ const wiring = createActivityPhaseWiring({
+ getContentParts: () => parts,
+ bumpIndexOffset: jest.fn(),
+ emitLabelEvent: jest.fn(async () => undefined),
+ trackPendingFill: jest.fn(),
+ generatePhase: jest.fn(async () => ({})),
+ });
+ let expectedFailed = 0;
+ for (let index = 0; index < total; index += 1) {
+ const id = `tool-${index}`;
+ const failed = failEvery > 0 && index % failEvery === 0;
+ expectedFailed += failed ? 1 : 0;
+ parts.push({ type: ContentTypes.TOOL_CALL, tool_call: { id } });
+ const entry = {
+ toolName: 'web_search',
+ toolInput: { query: id },
+ toolUseId: id,
+ status: failed ? ('error' as const) : ('success' as const),
+ ...(failed ? { error: 'boom' } : { toolOutput: `${id}-result` }),
+ };
+ await wiring.hook(
+ {
+ hook_event_name: 'PostToolBatch',
+ runId: 'run-1',
+ executingAgentId: `agent-${index % agents}`,
+ entries: [entry],
+ } as PostToolBatchHookInput,
+ new AbortController().signal,
+ );
+ }
+
+ const snapshot = wiring.snapshot();
+ expect(snapshot.activityCount).toBe(total);
+ expect(snapshot.failedActivityCount).toBe(expectedFailed);
+ expect(totalTrackedCount(snapshot.activities)).toBe(total);
+ const attributed = new Set(
+ snapshot.activities.flatMap((activity) => [
+ ...(activity.agentId != null ? [activity.agentId] : []),
+ ...(activity.mergedAgentIds ?? []),
+ ]),
+ );
+ expect(attributed.size).toBe(agents);
+ /** Folding must not reorder: a later boundary would otherwise claim work
+ * that happened before it. */
+ const positions = snapshot.activities.map((activity) => activity.startIndex);
+ expect(positions).toEqual([...positions].sort((left, right) => left - right));
+ });
+
it('carries an unresolved position through a folded anchor', async () => {
const parts: LooseContentPart[] = [];
const wiring = createActivityPhaseWiring({
diff --git a/packages/api/src/agents/activityPhases/runtime.ts b/packages/api/src/agents/activityPhases/runtime.ts
index 371369ce51..b3acca5a7f 100644
--- a/packages/api/src/agents/activityPhases/runtime.ts
+++ b/packages/api/src/agents/activityPhases/runtime.ts
@@ -471,6 +471,104 @@ function closesBeforeBoundary(
return materializedStart == null || materializedStart < boundary;
}
+/**
+ * Every field of a bounded anchor, stated explicitly. Anchors are built by
+ * demoting an activity and by folding two together, and both used to spread
+ * one side and hand-pick the rest — so any field nobody named was dropped
+ * silently, and nothing failed until a boundary happened to land badly.
+ * Mapping over `keyof Required<TrackedActivity>` makes every field mandatory
+ * at the construction site: adding one to `TrackedActivity` is a type error
+ * until its anchor semantics are decided here.
+ */
+type AnchorFields = { [K in keyof Required<TrackedActivity>]: TrackedActivity[K] };
+
+function laterDefinedIndex(earlier?: number, later?: number): number | undefined {
+ if (earlier == null) {
+ return later;
+ }
+ return later == null ? earlier : Math.max(earlier, later);
+}
+
+function foldedAgentIds(earlier: TrackedActivity, later: TrackedActivity): string[] | undefined {
+ const folded = [
+ ...new Set(
+ [
+ ...(earlier.mergedAgentIds ?? []),
+ ...(earlier.agentId != null ? [earlier.agentId] : []),
+ ...(later.mergedAgentIds ?? []),
+ ...(later.agentId != null ? [later.agentId] : []),
+ ].filter((id) => id !== earlier.agentId),
+ ),
+ ];
+ return folded.length > 0 ? folded : undefined;
+}
+
+/** Strips prompt evidence while keeping everything a boundary reasons about. */
+function boundedAnchor(activity: TrackedActivity): TrackedActivity {
+ const fields: AnchorFields = {
+ startIndex: activity.startIndex,
+ bounded: true,
+ status: activity.status,
+ partitionStartIndex: activity.partitionStartIndex,
+ unresolvedToolStartIndex: activity.unresolvedToolStartIndex,
+ toolCallIds: activity.toolCallIds?.slice(-MAX_RETAINED_TOOL_ENTRIES),
+ thinkingExcerpts: activity.thinkingExcerpts
+ ?.slice(-MAX_RETAINED_TOOL_ENTRIES)
+ .map((text) => text.slice(-REASONING_ANCHOR_CHARS)),
+ agentId: activity.agentId,
+ mergedCount: activity.mergedCount,
+ mergedFailedCount: activity.mergedFailedCount,
+ mergedPartialCount: activity.mergedPartialCount,
+ mergedAgentIds: activity.mergedAgentIds,
+ /** An anchor is never summarized directly, so prompt evidence and the
+ * child-label slot are deliberately not carried. */
+ label: undefined,
+ entries: undefined,
+ childLabelIndex: undefined,
+ };
+ return fields;
+}
+
+/** Folds `later` into `earlier`, which keeps its position. */
+function mergeAnchors(earlier: TrackedActivity, later: TrackedActivity): TrackedActivity {
+ const mergedFailedCount = countFailedActivities([earlier, later]);
+ const mergedPartialCount = countPartialActivities([earlier, later]);
+ const excerpts =
+ earlier.thinkingExcerpts != null || later.thinkingExcerpts != null
+ ? [...(earlier.thinkingExcerpts ?? []), ...(later.thinkingExcerpts ?? [])].slice(
+ -MAX_RETAINED_TOOL_ENTRIES,
+ )
+ : undefined;
+ const fields: AnchorFields = {
+ /** The pair starts where its first activity did; the later side's floor
+ * describes a position being absorbed and must not move the survivor. */
+ startIndex: earlier.startIndex,
+ partitionStartIndex: earlier.partitionStartIndex,
+ bounded: true,
+ status: earlier.status,
+ /** The later side may still be waiting on a tool call. Dropping its
+ * fallback lets a boundary close the whole merged count on the earlier
+ * side; resolution clears it once every retained id materializes. */
+ unresolvedToolStartIndex: laterDefinedIndex(
+ earlier.unresolvedToolStartIndex,
+ later.unresolvedToolStartIndex,
+ ),
+ toolCallIds: [...(earlier.toolCallIds ?? []), ...(later.toolCallIds ?? [])].slice(
+ -MAX_RETAINED_TOOL_ENTRIES,
+ ),
+ thinkingExcerpts: excerpts,
+ agentId: earlier.agentId,
+ mergedCount: (earlier.mergedCount ?? 1) + (later.mergedCount ?? 1),
+ mergedFailedCount: mergedFailedCount > 0 ? mergedFailedCount : undefined,
+ mergedPartialCount: mergedPartialCount > 0 ? mergedPartialCount : undefined,
+ mergedAgentIds: foldedAgentIds(earlier, later),
+ label: undefined,
+ entries: undefined,
+ childLabelIndex: undefined,
+ };
+ return fields;
+}
+
/** Every activity is represented by exactly one positioned item, so run totals
* are a sum over that list rather than a separately maintained scalar. */
function countActivities(activities: ReadonlyArray<TrackedActivity>): number {
@@ -746,30 +844,6 @@ export function createActivityPhaseWiring(deps: ActivityPhaseHostDeps): Activity
>();
const textContextByStepId = new Map<string, AssistantContextEntry>();
- const toBoundedAnchor = (activity: TrackedActivity): TrackedActivity => ({
- startIndex: activity.startIndex,
- bounded: true,
- ...(activity.partitionStartIndex != null && {
- partitionStartIndex: activity.partitionStartIndex,
- }),
- ...(activity.unresolvedToolStartIndex != null && {
- unresolvedToolStartIndex: activity.unresolvedToolStartIndex,
- }),
- ...(activity.toolCallIds != null && {
- toolCallIds: activity.toolCallIds.slice(-MAX_RETAINED_TOOL_ENTRIES),
- }),
- ...(activity.thinkingExcerpts != null && {
- thinkingExcerpts: activity.thinkingExcerpts
- .slice(-MAX_RETAINED_TOOL_ENTRIES)
- .map((text) => text.slice(-REASONING_ANCHOR_CHARS)),
- }),
- ...(activity.agentId != null && { agentId: activity.agentId }),
- ...(activity.mergedCount != null && { mergedCount: activity.mergedCount }),
- ...(activity.mergedFailedCount != null && { mergedFailedCount: activity.mergedFailedCount }),
- ...(activity.mergedPartialCount != null && { mergedPartialCount: activity.mergedPartialCount }),
- status: activity.status,
- });
-
/** Keeps memory bounded without letting an activity lose its position:
* evidence is dropped first, then the oldest anchors fold forward into their
* successor, which is never earlier in the content and so cannot move a
@@ -784,7 +858,7 @@ export function createActivityPhaseWiring(deps: ActivityPhaseHostDeps): Activity
evidenceBudget -= 1;
return activity;
}
- return toBoundedAnchor(activity);
+ return boundedAnchor(activity);
});
/** Merging the closest pair keeps the folded count on the side it was
* already on: a boundary can only fall at a content index, so merging
@@ -814,50 +888,9 @@ export function createActivityPhaseWiring(deps: ActivityPhaseHostDeps): Activity
const laterPosition = anchorPositions[mergeAt];
const earlier = activities[earlierPosition];
const later = activities[laterPosition];
- const mergedCount = (earlier.mergedCount ?? 1) + (later.mergedCount ?? 1);
- const mergedFailedCount = countFailedActivities([earlier, later]);
- const mergedPartialCount = countPartialActivities([earlier, later]);
activities.splice(laterPosition, 1);
- const foldedAgentIds = [
- ...new Set(
- [
- ...(earlier.mergedAgentIds ?? []),
- ...(earlier.agentId != null ? [earlier.agentId] : []),
- ...(later.mergedAgentIds ?? []),
- ...(later.agentId != null ? [later.agentId] : []),
- ].filter((id) => id !== earlier.agentId),
- ),
- ];
- /** The later side may be waiting on a tool call that has not appeared.
- * Dropping its fallback would let a boundary close the whole merged
- * count on the earlier side and strand that call outside its parent;
- * resolution clears the anchor once every retained id materializes. */
- const mergedUnresolved = Math.max(
- earlier.unresolvedToolStartIndex ?? -1,
- later.unresolvedToolStartIndex ?? -1,
- );
- activities[earlierPosition] = {
- ...earlier,
- ...(mergedUnresolved >= 0 && { unresolvedToolStartIndex: mergedUnresolved }),
- ...(foldedAgentIds.length > 0 && { mergedAgentIds: foldedAgentIds }),
- toolCallIds: [...(earlier.toolCallIds ?? []), ...(later.toolCallIds ?? [])].slice(
- -MAX_RETAINED_TOOL_ENTRIES,
- ),
- ...(earlier.thinkingExcerpts != null || later.thinkingExcerpts != null
- ? {
- thinkingExcerpts: [
- ...(earlier.thinkingExcerpts ?? []),
- ...(later.thinkingExcerpts ?? []),
- ].slice(-MAX_RETAINED_TOOL_ENTRIES),
- }
- : {}),
- mergedCount,
- ...(mergedFailedCount > 0 && { mergedFailedCount }),
- ...(mergedPartialCount > 0 && { mergedPartialCount }),
- };
+ activities[earlierPosition] = mergeAnchors(earlier, later);
}
- const folded = activities;
- activities = folded;
};
const applyRetained = (retained: PhasePartitionSide) => {