import {
resolveIdleCompaction,
type ModelSelection,
type OrchestrationV2ProviderTurn,
type OrchestrationV2ProviderTurnTokenUsage,
type OrchestrationV2ProviderThread,
type ServerProvider,
type ServerSettings,
type ThreadTokenUsageSnapshot,
} from "@t3tools/contracts";
import {
CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,
COMPACTION_SUGGESTION_MIN_TOKENS,
isClaudeResumeCompactionQuestion,
} from "@t3tools/shared/claudeCompaction";
import * as DateTime from "effect/DateTime";
import { resolvePendingHandoff } from "../handoff.ts";
import type { ThreadStructure, ThreadStructureTurnItem } from "./models.ts";
// Fallback TTL: Claude's 1h cache plus slack.
const CLAUDE_RESUME_COMPACTION_FALLBACK_MS = 70 * 60_000;
// A typed `/compact`, with or without instructions, is already the compaction. Queueing a
// bare one ahead of it would run an uninstructed compaction first and charge for two.
export const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s|$)/i;
function asFiniteNumber(value: unknown): number | null {
return typeof value === "number" && Number.isFinite(value) ? value : null;
}
type NullableContextWindowUsage = {
readonly [Key in keyof ThreadTokenUsageSnapshot]: undefined extends ThreadTokenUsageSnapshot[Key]
? Exclude<ThreadTokenUsageSnapshot[Key], undefined> | null
: ThreadTokenUsageSnapshot[Key];
};
export type ContextWindowSnapshot = NullableContextWindowUsage & {
readonly remainingTokens: number | null;
readonly usedPercentage: number | null;
readonly remainingPercentage: number | null;
readonly updatedAt: string;
};
/** Newest report by timestamp; snapshots order turns by provider thread. */
export function latestProviderTurnTokenUsage(
turns: ReadonlyArray<Pick<OrchestrationV2ProviderTurn, "tokenUsage">>,
projection?: Pick<ThreadStructure, "thread" | "contextTransfers"> | null,
providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage"> | null,
): OrchestrationV2ProviderTurnTokenUsage | null {
let latest: OrchestrationV2ProviderTurnTokenUsage | null = null;
for (const { tokenUsage } of turns) {
if (tokenUsage === undefined) continue;
// Ties go to the later entry, since live upserts append.
if (latest === null || Date.parse(tokenUsage.updatedAt) >= Date.parse(latest.updatedAt)) {
latest = tokenUsage;
}
}
if (latest !== null || projection == null || providerThread?.contextUsage != null) return latest;
const forkedFrom = projection.thread.forkedFrom;
if (forkedFrom?.type !== "run") return null;
return (
projection.contextTransfers.find(
(transfer) =>
transfer.type === "fork" &&
transfer.targetThreadId === projection.thread.id &&
transfer.sourceThreadId === forkedFrom.threadId &&
transfer.sourcePoint.runId === forkedFrom.runId &&
transfer.sourceProviderInstanceId === projection.thread.modelSelection.instanceId &&
(transfer.status === "pending" || transfer.resolution?.strategy === "native_fork"),
)?.sourceTokenUsage ?? null
);
}
export function deriveLatestContextWindowSnapshot(
entries: ReadonlyArray<{
readonly item: ThreadStructureTurnItem;
}>,
liveUsage?: OrchestrationV2ProviderTurnTokenUsage | null,
providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage" | "updatedAt"> | null,
): ContextWindowSnapshot | null {
if (liveUsage != null) {
const usedTokens = Math.max(0, liveUsage.usedTokens);
const maxTokens = liveUsage.maxTokens ?? null;
const usedPercentage =
maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;
const remainingTokens =
maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;
const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;
return {
usedTokens,
totalProcessedTokens: null,
maxTokens,
remainingTokens,
usedPercentage,
remainingPercentage,
inputTokens: liveUsage.inputTokens ?? null,
cachedInputTokens: liveUsage.cachedInputTokens ?? null,
outputTokens: liveUsage.outputTokens ?? null,
reasoningOutputTokens: liveUsage.reasoningOutputTokens ?? null,
lastUsedTokens: null,
lastInputTokens: null,
lastCachedInputTokens: null,
lastOutputTokens: null,
lastReasoningOutputTokens: null,
toolUses: null,
durationMs: null,
compactsAutomatically: true,
autoCompactThreshold: liveUsage.autoCompactThreshold ?? null,
cost: null,
updatedAt: liveUsage.updatedAt,
};
}
const providerUsage = providerThread?.contextUsage;
const providerUsageUpdatedAt = providerThread?.updatedAt;
if (
providerUsage !== null &&
providerUsage !== undefined &&
providerUsageUpdatedAt !== undefined
) {
const maxTokens = asFiniteNumber(providerUsage.maxTokens);
const usedTokens = providerUsage.usedTokens;
const usedPercentage =
maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;
return {
usedTokens,
totalProcessedTokens: asFiniteNumber(providerUsage.totalProcessedTokens),
maxTokens,
remainingTokens: maxTokens === null ? null : Math.max(0, Math.round(maxTokens - usedTokens)),
usedPercentage,
remainingPercentage: usedPercentage === null ? null : Math.max(0, 100 - usedPercentage),
inputTokens: asFiniteNumber(providerUsage.inputTokens),
cachedInputTokens: asFiniteNumber(providerUsage.cachedInputTokens),
outputTokens: asFiniteNumber(providerUsage.outputTokens),
reasoningOutputTokens: asFiniteNumber(providerUsage.reasoningOutputTokens),
lastUsedTokens: asFiniteNumber(providerUsage.lastUsedTokens),
lastInputTokens: asFiniteNumber(providerUsage.lastInputTokens),
lastCachedInputTokens: asFiniteNumber(providerUsage.lastCachedInputTokens),
lastOutputTokens: asFiniteNumber(providerUsage.lastOutputTokens),
lastReasoningOutputTokens: asFiniteNumber(providerUsage.lastReasoningOutputTokens),
toolUses: asFiniteNumber(providerUsage.toolUses),
durationMs: asFiniteNumber(providerUsage.durationMs),
compactsAutomatically: providerUsage.compactsAutomatically ?? null,
cost: providerUsage.cost ?? null,
autoCompactThreshold: providerUsage.autoCompactThreshold ?? null,
updatedAt: DateTime.formatIso(providerUsageUpdatedAt),
};
}
for (let index = entries.length - 1; index >= 0; index -= 1) {
const entry = entries[index];
if (!entry || entry.item.type !== "compaction") {
continue;
}
const payload = entry.item;
const usedTokens = asFiniteNumber(payload.afterTokenCount);
if (usedTokens === null || usedTokens < 0) {
continue;
}
const maxTokens = null;
const usedPercentage =
maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;
const remainingTokens =
maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;
const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;
return {
usedTokens,
totalProcessedTokens: asFiniteNumber(payload.beforeTokenCount),
maxTokens,
remainingTokens,
usedPercentage,
remainingPercentage,
inputTokens: null,
cachedInputTokens: null,
outputTokens: null,
reasoningOutputTokens: null,
lastUsedTokens: null,
lastInputTokens: null,
lastCachedInputTokens: null,
lastOutputTokens: null,
lastReasoningOutputTokens: null,
toolUses: null,
durationMs: null,
compactsAutomatically: true,
autoCompactThreshold: null,
cost: null,
updatedAt: DateTime.formatIso(payload.startedAt ?? payload.updatedAt),
};
}
return null;
}
export function hasDismissedResumeCompaction(
activities: ReadonlyArray<{ readonly kind: string; readonly payload: unknown }>,
): boolean {
return activities.some((activity) => {
if (activity.kind !== "user-input.resolved") return false;
const payload = activity.payload;
if (!payload || typeof payload !== "object") return false;
const answers = (payload as { readonly answers?: unknown }).answers;
if (!answers || typeof answers !== "object" || Array.isArray(answers)) return false;
return Object.entries(answers).some(
([question, answer]) =>
isClaudeResumeCompactionQuestion(question) &&
answer === CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,
);
});
}
export function shouldOfferResumeCompaction(input: {
readonly provider: string | null | undefined;
readonly usedTokens: number | null | undefined;
readonly updatedAt: string | null | undefined;
readonly promptCacheTtlMs?: number | undefined;
readonly now: string;
}): boolean {
if (
input.provider !== "claudeAgent" ||
(input.usedTokens ?? 0) < COMPACTION_SUGGESTION_MIN_TOKENS
) {
return false;
}
const updatedAt = Date.parse(input.updatedAt ?? "");
const now = Date.parse(input.now);
return (
Number.isFinite(updatedAt) &&
Number.isFinite(now) &&
now - updatedAt >= (input.promptCacheTtlMs ?? CLAUDE_RESUME_COMPACTION_FALLBACK_MS)
);
}
/**
* Whether a plain send into an idle thread compacts it first, as web's composer does under
* "When you return". Web reads the same state for its "Compact and send" button. A send that
* hands off to another conversation starts that one fresh, so only the resumed one counts.
*/
export function shouldCompactBeforeSend(input: {
readonly projection: Pick<
ThreadStructure,
| "thread"
| "contextTransfers"
| "providerThreads"
| "providerTurns"
| "runtimeRequests"
| "runs"
| "visibleTurnItems"
>;
readonly visibleTurnItems: ReadonlyArray<{ readonly item: ThreadStructureTurnItem }>;
readonly selection: ModelSelection;
readonly providers: ReadonlyArray<ServerProvider>;
readonly settings: Pick<
ServerSettings,
"providerInstances" | "compactIdleThreads" | "idleCompaction"
>;
readonly text: string;
readonly threadIdle: boolean;
readonly now: string;
}): boolean {
const { projection } = input;
const provider = input.providers.find((entry) => entry.instanceId === input.selection.instanceId);
if (
provider === undefined ||
!input.threadIdle ||
COMPACT_COMMAND_PATTERN.test(input.text) ||
resolveIdleCompaction(input.settings, provider.instanceId) === "off" ||
!provider.slashCommands.some((command) => command.name === "compact") ||
resolvePendingHandoff(projection, input.selection, input.providers) !== null ||
projection.runtimeRequests.some((request) => request.status === "pending") ||
projection.runs.some((run) => run.status === "queued" && run.queueHeld === true) ||
(!input.visibleTurnItems.some(
({ item }) =>
item.type === "user_message" &&
(item.text.trim().toLowerCase() !== "/compact" || item.attachments.length > 0),
) &&
!projection.runs.some(
(run) =>
run.status !== "rolled_back" &&
run.startedAt !== null &&
!input.visibleTurnItems.some(
({ item }) => item.type === "user_message" && item.runId === run.id,
),
)) ||
hasDismissedResumeCompaction(
projection.runtimeRequests
.filter((request) => request.kind === "user_input" && request.status === "resolved")
.map((request) => ({ kind: "user-input.resolved", payload: { answers: request.answers } })),
)
) {
return false;
}
const activeProviderThreadId = projection.thread.activeProviderThreadId;
const providerThread = projection.providerThreads.find(
(thread) => thread.id === activeProviderThreadId,
);
const liveUsage = latestProviderTurnTokenUsage(
projection.providerTurns.filter((turn) => turn.providerThreadId === activeProviderThreadId),
input.selection.instanceId === projection.thread.modelSelection.instanceId ? projection : null,
providerThread,
);
const contextWindow = deriveLatestContextWindowSnapshot(
input.visibleTurnItems,
liveUsage,
providerThread,
);
return (
contextWindow !== null &&
shouldOfferResumeCompaction({
provider: provider.driver,
usedTokens: contextWindow.usedTokens,
updatedAt: contextWindow.updatedAt,
promptCacheTtlMs: liveUsage?.promptCacheTtlMs,
now: input.now,
})
);
}