上下文压缩

export interface CompactionSnapshot {  id: string;  createdAt: string;  sourceEventRange: { from: number; to: number };  goal: string;  constraints: string[];  decisions: Array<{ statement: string; evidenceEventIds: string[] }>;  completedWork: Array<{ stepId: string; evidence: string[] }>;  pendingWork: Array<{ stepId: string; reason: string }>;  acceptanceCriteria: AcceptanceCriterion[];  activeSkills: string[];  changedFiles: string[];  validationResults: ValidationRecord[];  unresolvedQuestions: string[];  failedAttempts: string[];  checksum: string;}export interface CompactionState {  snapshots: CompactionSnapshot[];  compactedThroughEvent: number;  providerItems?: unknown[];}export interface AgentState {  // 保留 runId、task、plan、messages、contextSources、skills、steps 等字段  compaction: CompactionState;}export interface ContextKindMap {  compaction_snapshot: true;}

export interface ContextUsage {  estimatedInputTokens: number;  contextWindowTokens: number;  reservedOutputTokens: number;}export function shouldCompact(usage: ContextUsage): boolean {  const usableInput = usage.contextWindowTokens - usage.reservedOutputTokens;  const trigger = Math.floor(usableInput * 0.8);  return usage.estimatedInputTokens >= trigger;}export function isSafeCompactionBoundary(input: {  status: AgentState["status"];  pendingToolCallCount: number;  pendingOutputCount: number;}): boolean {  return (    input.status === "running" &&    input.pendingToolCallCount === 0 &&    input.pendingOutputCount === 0  );}

export interface CompactorInput {  task: string;  plan: TaskPlan;  events: AgentEvent[];  activeSkillNames: string[];  changedFiles: string[];}export interface Compactor {  compact(input: CompactorInput): Promise<Omit<CompactionSnapshot, "id" | "createdAt" | "checksum">>;}export async function buildCompactionSnapshot(options: {  state: AgentState;  events: AgentEvent[];  compactor: Compactor;}): Promise<CompactionSnapshot> {  if (!options.state.plan) throw new Error("cannot compact before plan initialization");  const from = options.state.compaction.compactedThroughEvent + 1;  const to = options.events.at(-1)?.sequence ?? from - 1;  const draft = await options.compactor.compact({    task: options.state.task,    plan: options.state.plan,    events: options.events.filter((event) => event.sequence >= from && event.sequence <= to),    activeSkillNames: Object.keys(options.state.skills.activeSkills),    changedFiles: options.state.changedFiles,  });  const snapshotWithoutChecksum = {    ...draft,    id: crypto.randomUUID(),    createdAt: new Date().toISOString(),    sourceEventRange: { from, to },  };  return {    ...snapshotWithoutChecksum,    checksum: sha256(canonicalJson(snapshotWithoutChecksum)),  };}

const compacted = await openai.responses.compact({  model,  input: responseItems,  instructions: systemPrompt,});state.compaction.providerItems = compacted.output;

export function validateCompaction(  snapshot: CompactionSnapshot,  state: AgentState,  events: AgentEvent[],): void {  if (snapshot.goal !== state.task) throw new Error("snapshot goal changed");  if (!state.plan) throw new Error("cannot validate compaction without a plan");  assertStringSetEqual(snapshot.constraints, state.constraints, "constraints");  assertCriteriaEqual(snapshot.acceptanceCriteria, state.plan.acceptanceCriteria);  assertCompletedWorkEqual(snapshot.completedWork, state.plan.steps);  const pendingIds = new Set(snapshot.pendingWork.map((step) => step.stepId));  for (const step of state.plan.steps.filter((step) => step.status !== "completed")) {    if (!pendingIds.has(step.id)) throw new Error(`missing pending step: ${step.id}`);  }  for (const file of state.changedFiles) {    if (!snapshot.changedFiles.includes(file)) throw new Error(`missing changed file: ${file}`);  }  assertStringSetEqual(snapshot.activeSkills, Object.keys(state.skills.activeSkills), "skills");  assertStringSetEqual(snapshot.failedAttempts, state.failedAttempts, "failed attempts");  if (canonicalJson(snapshot.validationResults) !== canonicalJson(state.validations)) {    throw new Error("validation evidence changed during compaction");  }  const unresolvedQuestions = state.pendingUserInput ? [state.pendingUserInput.question] : [];  assertStringSetEqual(snapshot.unresolvedQuestions, unresolvedQuestions, "unresolved questions");  for (const decision of snapshot.decisions) {    for (const eventId of decision.evidenceEventIds) {      if (        !events.some(          (event) =>            event.eventId === eventId &&            event.sequence >= snapshot.sourceEventRange.from &&            event.sequence <= snapshot.sourceEventRange.to,        )      ) {        throw new Error(`unknown evidence event: ${eventId}`);      }    }  }  if (snapshot.sourceEventRange.to < snapshot.sourceEventRange.from) {    throw new Error("empty compaction range");  }}function assertCriteriaEqual(  actual: AcceptanceCriterion[],  expected: AcceptanceCriterion[],): void {  if (canonicalJson(actual) !== canonicalJson(expected)) {    throw new Error("acceptance criteria changed during compaction");  }}function assertCompletedWorkEqual(actual: CompactionSnapshot["completedWork"], steps: PlanStep[]): void {  const expected = steps    .filter((step) => step.status === "completed")    .map((step) => ({ stepId: step.id, evidence: step.evidence }));  if (canonicalJson(actual) !== canonicalJson(expected)) {    throw new Error("completed work changed during compaction");  }}

export interface CompactedContext {  snapshot: CompactionSnapshot;  rawTail: AgentEvent[];}export function projectCompactedContext(options: {  snapshot: CompactionSnapshot;  events: AgentEvent[];  rawTailSize: number;}): CompactedContext {  const rawTailBoundary = selectRawTailBoundary(    options.events,    options.snapshot,    options.rawTailSize,  );  return {    snapshot: options.snapshot,    rawTail: options.events.filter((event) => event.sequence >= rawTailBoundary),  };}function selectRawTailBoundary(  events: AgentEvent[],  snapshot: CompactionSnapshot,  rawTailSize: number,): number {  const lastN = events.at(-rawTailSize)?.sequence ?? snapshot.sourceEventRange.from;  const currentStep = events.findLast((event) => event.type === "step_started")?.sequence;  const lastUserInput = events.findLast((event) => event.type === "user_input")?.sequence;  const lastToolBatch = events.findLast((event) => event.type === "tool_batch_started")?.sequence;  return Math.min(    lastN,    ...[currentStep, lastUserInput, lastToolBatch].filter(      (sequence): sequence is number => sequence !== undefined,    ),  );}export function compactionAsContextSources(context: CompactedContext): ContextSource[] {  return [    {      id: `compaction:${context.snapshot.id}`,      kind: "compaction_snapshot",      label: "Verified task memory",      content: JSON.stringify(context.snapshot),      priority: 95,    },    ...context.rawTail.map(eventAsContextSource),  ];}

export async function maybeCompactContext(options: {  state: AgentState;  events: AgentEvent[];  usage: ContextUsage;  pendingToolCallCount: number;  pendingOutputCount: number;  compactor: Compactor;  emit: (event: AgentEventInput) => Promise<void>;}): Promise<void> {  if (!shouldCompact(options.usage)) return;  if (    !isSafeCompactionBoundary({      status: options.state.status,      pendingToolCallCount: options.pendingToolCallCount,      pendingOutputCount: options.pendingOutputCount,    })  ) {    return;  }  await options.emit({ type: "compaction_started", through: options.events.at(-1)?.sequence ?? 0 });  const snapshot = await buildCompactionSnapshot(options);  validateCompaction(snapshot, options.state, options.events);  options.state.compaction.snapshots.push(snapshot);  options.state.compaction.compactedThroughEvent = snapshot.sourceEventRange.to;  await options.emit({    type: "compaction_completed",    snapshotId: snapshot.id,    sourceEventRange: snapshot.sourceEventRange,  });}

OBSERVE tool resultsUPDATE plan and acceptance evidencePERSIST events and stateMAYBE COMPACT at a safe boundaryASSEMBLE authoritative state + latest snapshot + rawTailCALL model

it("keeps authoritative task state and only replaces old history", async () => {  const state = createLongRunningFixture();  const events = createEventsThroughCompletedStep();  await maybeCompactContext({    state,    events,    usage: {      estimatedInputTokens: 82_000,      contextWindowTokens: 100_000,      reservedOutputTokens: 10_000,    },    compactor: createFakeCompactor(),    emit: appendFixtureEvent,  });  const snapshot = state.compaction.snapshots.at(-1);  expect(snapshot?.goal).toBe(state.task);  expect(snapshot?.pendingWork.map((step) => step.stepId)).toContain("run-tests");  expect(snapshot?.changedFiles).toEqual(state.changedFiles);  expect(state.plan.steps).toEqual(originalPlan);});