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: Resolve Activity Phase Position Once Per Boundary (#14807)

Danny Avila78eb0c98ce2d
diff --git a/packages/api/src/agents/activityPhases/runtime.ts b/packages/api/src/agents/activityPhases/runtime.ts
index b3acca5a7f..37f2708da5 100644
--- a/packages/api/src/agents/activityPhases/runtime.ts
+++ b/packages/api/src/agents/activityPhases/runtime.ts
@@ -447,28 +447,168 @@ interface PhasePartition {
}
/**
- * Whether an activity belongs to the phase closing at `boundary`. Shared by
- * the boundary partition and the completion boundary so the two cannot drift
- * on what counts as work lying after a given index.
+ * Where an activity sits in the live content, resolved once. Positional fields
+ * on `TrackedActivity` are captured at different times against an array that
+ * keeps moving — parts materialize after their hooks fire, label reservations
+ * shift indices, persistence compacts, resume prepends — so each is an input
+ * here rather than something a boundary consults directly.
*/
-function closesBeforeBoundary(
+interface ResolvedPosition {
+ /** Materialized indices of this activity's tool calls, ascending. */
+ toolIndices: number[];
+ /** Where the activity begins once anchors and prior floors are applied. */
+ startsAt: number;
+ /** The highest index this activity is known to reach, including a saved
+ * fallback for calls that have not materialized yet. `undefined` when
+ * nothing in the live content locates it at all. */
+ endsAt?: number;
+ /** Whether the saved fallback is still doing work. Once every tracked call
+ * has materialized it is stale, and persisting it would hold the activity
+ * past a boundary its real position precedes after a resume. */
+ awaitingTools: boolean;
+}
+
+function resolvePosition(
parts: ReadonlyArray<LooseContentPart | null | undefined>,
activity: TrackedActivity,
- boundary: number | undefined,
- toolIndices?: number[],
-): boolean {
+): ResolvedPosition {
+ const toolIndices = findTrackedToolIndices(parts, activity);
+ const toolStart = toolIndices[0];
+ /** A saved fallback outlives its purpose once every tracked call has
+ * materialized; keeping it would hold the activity past a boundary its
+ * real position precedes. */
+ const trackedToolCount = activity.toolCallIds?.length ?? 0;
+ const awaitingTools = trackedToolCount === 0 || toolIndices.length < trackedToolCount;
+ const fallback = awaitingTools ? activity.unresolvedToolStartIndex : undefined;
+ if (toolStart != null) {
+ return {
+ toolIndices,
+ awaitingTools,
+ startsAt: Math.max(toolStart, activity.partitionStartIndex ?? 0),
+ endsAt: Math.max(toolIndices[toolIndices.length - 1], fallback ?? Number.NEGATIVE_INFINITY),
+ };
+ }
+ /** Anchors carry only stable evidence and must be re-located against the
+ * current content; a full activity keeps the index maintained live, which
+ * repeated reasoning must not drag back across a prior phase. */
+ const startsAt =
+ activity.bounded === true ? findTrackedStart(parts, activity) : activity.startIndex;
+ const materializedStart = findMaterializedActivityStart(parts, activity, toolIndices);
+ const located =
+ fallback != null ? Math.max(fallback, materializedStart ?? fallback) : materializedStart;
+ return { toolIndices, awaitingTools, startsAt, ...(located != null && { endsAt: located }) };
+}
+
+/**
+ * Whether an activity belongs to the phase closing at `boundary`. Takes only a
+ * resolved position, so no caller can reach past it to a raw field: an
+ * activity closes early exactly when nothing locates it beyond the boundary.
+ * A completed batch straddling the boundary therefore stays whole on the later
+ * side rather than leaving one tool call outside its own parent.
+ */
+function closesBeforeBoundary(position: ResolvedPosition, boundary: number | undefined): boolean {
if (boundary == null) {
return true;
}
- if (activity.unresolvedToolStartIndex != null && activity.unresolvedToolStartIndex >= boundary) {
- return false;
- }
- const materializedToolIndices = toolIndices ?? findTrackedToolIndices(parts, activity);
- if (materializedToolIndices.length > 0) {
- return materializedToolIndices.every((index) => index < boundary);
+ return position.endsAt == null || position.endsAt < 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;
}
- const materializedStart = findMaterializedActivityStart(parts, activity, materializedToolIndices);
- return materializedStart == null || materializedStart < boundary;
+ 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;
}
/**
@@ -1083,41 +1223,23 @@ export function createActivityPhaseWiring(deps: ActivityPhaseHostDeps): Activity
* where a retained straddling batch reanchors — so the shared content
* array is walked once per activity and the result carried through. */
const resolved = activities.map((activity) => {
- const toolIndices = findTrackedToolIndices(currentParts, activity);
- const toolStart = toolIndices[0];
- if (toolStart != null) {
- /** The saved fallback outlives its purpose once every tracked call has
- * materialized. Keeping it would reject the activity at any boundary
- * below that stale index even though its real position is earlier. */
- const fullyMaterialized =
- (activity.toolCallIds?.length ?? 0) > 0 &&
- toolIndices.length >= (activity.toolCallIds?.length ?? 0);
- const { unresolvedToolStartIndex, ...rest } = activity;
- return {
- activity: {
- ...rest,
- ...(!fullyMaterialized &&
- unresolvedToolStartIndex != null && { unresolvedToolStartIndex }),
- startIndex: Math.max(toolStart, activity.partitionStartIndex ?? 0),
- },
- toolIndices,
- };
- }
- /** Anchors carry only stable evidence and must be re-located against the
- * current content; a full activity keeps the index maintained live,
- * which repeated reasoning must not drag back across a prior phase. */
+ const position = resolvePosition(currentParts, activity);
+ const { unresolvedToolStartIndex, ...rest } = activity;
return {
- activity:
- activity.bounded === true
- ? { ...activity, startIndex: findTrackedStart(currentParts, activity) }
- : activity,
- toolIndices,
+ activity: {
+ ...rest,
+ ...(position.awaitingTools &&
+ unresolvedToolStartIndex != null && { unresolvedToolStartIndex }),
+ startIndex: position.startsAt,
+ },
+ toolIndices: position.toolIndices,
+ position,
};
});
const closingActivities: TrackedActivity[] = [];
const retainedActivities: TrackedActivity[] = [];
- for (const { activity, toolIndices } of resolved) {
- if (closesBeforeBoundary(currentParts, activity, requestedEndIndex, toolIndices)) {
+ for (const { activity, toolIndices, position } of resolved) {
+ if (closesBeforeBoundary(position, requestedEndIndex)) {
closingActivities.push(activity);
continue;
}
@@ -1592,7 +1714,11 @@ export function createActivityPhaseWiring(deps: ActivityPhaseHostDeps): Activity
return undefined;
}
const boundary = candidate;
- if (activities.some((activity) => !closesBeforeBoundary(parts, activity, boundary))) {
+ if (
+ activities.some(
+ (activity) => !closesBeforeBoundary(resolvePosition(parts, activity), boundary),
+ )
+ ) {
return undefined;
}
for (const reasoning of pendingReasoning.values()) {