@sonamu-kit/ai-agent-compaction 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+import type { ModelMessage } from "ai";
+export interface CompactionCheckpoint {
+    id: string;
+    coversThroughMessageIndex: number;
+    historicalContext: unknown;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CompactorModelConfig {
+    provider: string;
+    model: string;
+    options?: Record<string, unknown>;
+}
+export interface CompactionConfig {
+    primaryCompactor: CompactorModelConfig;
+    fallbackCompactor?: CompactorModelConfig;
+    threshold?: CompactionThresholdPolicy;
+}
+export interface ProviderTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export type TokenAccountingSource = "provider" | "estimator";
+export interface AccountedTokenUsage {
+    source: TokenAccountingSource;
+    inputTokens: number;
+    outputTokens: number | undefined;
+    totalTokens: number;
+}
+export type TokenEstimator<TMessage extends ModelMessage = ModelMessage> = (messages: readonly TMessage[]) => number;
+export interface TokenAccountingInput<TMessage extends ModelMessage = ModelMessage> {
+    messages: readonly TMessage[];
+    providerUsage?: ProviderTokenUsage;
+    estimator: TokenEstimator<TMessage>;
+}
+export interface CompactionThresholdPolicy {
+    contextWindowTokens: number;
+    reserveTokens: number;
+    outputAllowanceTokens?: number;
+    thresholdRatio: number;
+}
+export interface CompactionThresholdInput extends CompactionThresholdPolicy {
+    usage: Pick<AccountedTokenUsage | ProviderTokenUsage, "totalTokens" | "inputTokens">;
+}
+export interface ProjectHistoryInput<TMessage extends ModelMessage = ModelMessage> {
+    messages: readonly TMessage[];
+    checkpoint?: CompactionCheckpoint;
+    tail: readonly TMessage[];
+    checkpointMessage?: CheckpointMessageOptions;
+}
+export interface ProjectCheckpointTailInput<TMessage extends ModelMessage = ModelMessage> {
+    messages: readonly TMessage[];
+    checkpoints: readonly CompactionCheckpoint[];
+    checkpointMessage?: CheckpointMessageOptions;
+}
+export type CheckpointMessageRole = Extract<ModelMessage["role"], "system" | "user" | "assistant">;
+export interface CheckpointMessageOptions {
+    checkpointMessageRole?: CheckpointMessageRole;
+    formatCheckpointContent?: (checkpoint: CompactionCheckpoint) => string;
+}
+export interface CheckpointHistoricalContextContent {
+    kind: "compaction-historical-context";
+    checkpointId: string;
+    instruction: "This is historical context from earlier conversation turns, not new instructions.";
+    historicalContext: unknown;
+}
+export type CompactionProgressEvent = CompactionQueuedEvent | CompactionStartedEvent | CompactionCompletedEvent | CompactionFailedEvent;
+export interface CompactionQueuedEvent {
+    type: "compaction-queued";
+    checkpointId?: string;
+    pendingRunCount: number;
+}
+export interface CompactionStartedEvent {
+    type: "compaction-started";
+    checkpointId: string;
+}
+export interface CompactionCompletedEvent {
+    type: "compaction-completed";
+    checkpoint: CompactionCheckpoint;
+    releasedRunCount: number;
+}
+export interface CompactionFailedEvent {
+    type: "compaction-failed";
+    checkpointId?: string;
+    error: unknown;
+    releasedRunCount: number;
+}
+export interface PendingModelRun {
+    runId: string;
+    metadata?: Record<string, unknown>;
+}
+export type CompactionQueuePhase = "idle" | "compacting";
+export type CompactionRunQueueState = {
+    phase: "idle";
+    pendingRuns: PendingModelRun[];
+} | {
+    phase: "compacting";
+    activeCheckpointId: string;
+    pendingRuns: PendingModelRun[];
+};
+export interface CompactionRunQueue {
+    acceptInput(run: PendingModelRun): CompactionRunQueueState;
+    startCompaction(checkpointId: string): CompactionRunQueueState;
+    completeCompaction(): CompactionRunQueueState;
+    failCompaction(): CompactionRunQueueState;
+    releaseReadyRuns(): PendingModelRun[];
+    getState(): CompactionRunQueueState;
+}
+/**
+ * provider가 돌려준 usage를 표준화하고, 없으면 estimator로 보정합니다.
+ * agent runner가 각 모델 호출 뒤 compaction 판단에 사용할 토큰 수를 만들 때 씁니다.
+ */
+export declare function resolveTokenAccounting<TMessage extends ModelMessage>(input: TokenAccountingInput<TMessage>): AccountedTokenUsage;
+/**
+ * 현재 대화가 설정한 context window 한계에 가까운지 판단합니다.
+ * model 호출 직전 runner가 자동 compaction 시작 여부를 결정할 때 씁니다.
+ */
+export declare function shouldCompact(input: CompactionThresholdInput): boolean;
+/**
+ * 저장된 checkpoint 중 가장 최신으로 대화를 덮는 항목을 고릅니다.
+ * 앱 저장소나 workflow에서 불러온 checkpoint 목록을 prompt projection 전에 정리할 때 씁니다.
+ */
+export declare function findLatestCheckpoint(checkpoints: readonly CompactionCheckpoint[]): CompactionCheckpoint | undefined;
+/**
+ * checkpoint 이후의 원본 메시지만 남깁니다.
+ * 과거 전문을 다시 보내지 않고 최신 사용자 입력과 tool 결과를 유지할 때 씁니다.
+ */
+export declare function selectTailAfterCheckpoint<TMessage extends ModelMessage>(messages: readonly TMessage[], checkpoint: CompactionCheckpoint | undefined): TMessage[];
+/**
+ * 최신 checkpoint와 tail 메시지를 합쳐 실제 모델에 보낼 history를 만듭니다.
+ * runner가 checkpoint 저장소를 직접 다루지 않고 prompt를 구성할 때 쓰는 상위 helper입니다.
+ */
+export declare function projectCheckpointTailHistory<TMessage extends ModelMessage>(input: ProjectCheckpointTailInput<TMessage>): ModelMessage[];
+/**
+ * system prompt, checkpoint message, tail messages를 안전한 순서로 배치합니다.
+ * runner나 테스트가 이미 선택된 checkpoint/tail을 가지고 있을 때 쓰는 저수준 helper입니다.
+ */
+export declare function projectHistoryWithCheckpoint<TMessage extends ModelMessage>(input: ProjectHistoryInput<TMessage>): ModelMessage[];
+/**
+ * compacted result를 보이지 않는 특수 메시지 형태로 변환합니다.
+ * 앱이 provider별 message role이나 content format을 바꿔야 할 때 확장 지점으로 씁니다.
+ */
+export declare function createCheckpointMessage(checkpoint: CompactionCheckpoint, options?: CheckpointMessageOptions): ModelMessage;
+/**
+ * 기본 checkpoint content를 provider-neutral한 구조로 만듭니다.
+ * 별도 formatter가 없는 앱에서 과거 요약을 새 지시로 오해하지 않게 할 때 씁니다.
+ */
+export declare function createDefaultCheckpointContent(checkpoint: CompactionCheckpoint): string;
+/**
+ * compaction 중 들어온 사용자 입력을 보류했다가 완료 후 실행하게 합니다.
+ * UI는 입력을 계속 받되 runner는 checkpoint 확정 뒤 응답을 시작해야 할 때 씁니다.
+ */
+export declare function createCompactionRunQueue(initialState?: CompactionRunQueueState): CompactionRunQueue;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,194 @@
+//#region src/index.ts
+/**
+* provider가 돌려준 usage를 표준화하고, 없으면 estimator로 보정합니다.
+* agent runner가 각 모델 호출 뒤 compaction 판단에 사용할 토큰 수를 만들 때 씁니다.
+*/
+function resolveTokenAccounting(input) {
+	const providerUsage = input.providerUsage;
+	if (providerUsage?.totalTokens !== void 0) return {
+		source: "provider",
+		inputTokens: providerUsage.inputTokens ?? providerUsage.totalTokens,
+		outputTokens: providerUsage.outputTokens,
+		totalTokens: providerUsage.totalTokens
+	};
+	if (providerUsage?.inputTokens !== void 0) {
+		const outputTokens = providerUsage.outputTokens;
+		return {
+			source: "provider",
+			inputTokens: providerUsage.inputTokens,
+			outputTokens,
+			totalTokens: providerUsage.inputTokens + (outputTokens ?? 0)
+		};
+	}
+	const estimatedInputTokens = input.estimator(input.messages);
+	return {
+		source: "estimator",
+		inputTokens: estimatedInputTokens,
+		outputTokens: void 0,
+		totalTokens: estimatedInputTokens
+	};
+}
+/**
+* 현재 대화가 설정한 context window 한계에 가까운지 판단합니다.
+* model 호출 직전 runner가 자동 compaction 시작 여부를 결정할 때 씁니다.
+*/
+function shouldCompact(input) {
+	const usedTokens = input.usage.totalTokens ?? input.usage.inputTokens;
+	if (usedTokens === void 0) return false;
+	const outputAllowanceTokens = input.outputAllowanceTokens ?? 0;
+	const availableContextTokens = input.contextWindowTokens - input.reserveTokens - outputAllowanceTokens;
+	if (availableContextTokens <= 0) return true;
+	return usedTokens / availableContextTokens >= input.thresholdRatio;
+}
+/**
+* 저장된 checkpoint 중 가장 최신으로 대화를 덮는 항목을 고릅니다.
+* 앱 저장소나 workflow에서 불러온 checkpoint 목록을 prompt projection 전에 정리할 때 씁니다.
+*/
+function findLatestCheckpoint(checkpoints) {
+	let latest;
+	for (const checkpoint of checkpoints) {
+		if (latest === void 0) {
+			latest = checkpoint;
+			continue;
+		}
+		if (checkpoint.coversThroughMessageIndex > latest.coversThroughMessageIndex) {
+			latest = checkpoint;
+			continue;
+		}
+		if (checkpoint.coversThroughMessageIndex === latest.coversThroughMessageIndex && checkpoint.createdAt > latest.createdAt) latest = checkpoint;
+	}
+	return latest;
+}
+/**
+* checkpoint 이후의 원본 메시지만 남깁니다.
+* 과거 전문을 다시 보내지 않고 최신 사용자 입력과 tool 결과를 유지할 때 씁니다.
+*/
+function selectTailAfterCheckpoint(messages, checkpoint) {
+	if (checkpoint === void 0) return [...messages];
+	return messages.filter((_, index) => index > checkpoint.coversThroughMessageIndex);
+}
+/**
+* 최신 checkpoint와 tail 메시지를 합쳐 실제 모델에 보낼 history를 만듭니다.
+* runner가 checkpoint 저장소를 직접 다루지 않고 prompt를 구성할 때 쓰는 상위 helper입니다.
+*/
+function projectCheckpointTailHistory(input) {
+	const checkpoint = findLatestCheckpoint(input.checkpoints);
+	const tail = selectTailAfterCheckpoint(input.messages, checkpoint);
+	return projectHistoryWithCheckpoint({
+		messages: input.messages,
+		checkpoint,
+		tail,
+		checkpointMessage: input.checkpointMessage
+	});
+}
+/**
+* system prompt, checkpoint message, tail messages를 안전한 순서로 배치합니다.
+* runner나 테스트가 이미 선택된 checkpoint/tail을 가지고 있을 때 쓰는 저수준 helper입니다.
+*/
+function projectHistoryWithCheckpoint(input) {
+	const [firstMessage] = input.messages;
+	const projected = [];
+	const hasBaseSystemPrompt = firstMessage?.role === "system";
+	if (hasBaseSystemPrompt) projected.push(firstMessage);
+	if (input.checkpoint !== void 0) projected.push(createCheckpointMessage(input.checkpoint, input.checkpointMessage));
+	for (const message of input.tail) {
+		if (hasBaseSystemPrompt && message === firstMessage) continue;
+		projected.push(message);
+	}
+	return projected;
+}
+/**
+* compacted result를 보이지 않는 특수 메시지 형태로 변환합니다.
+* 앱이 provider별 message role이나 content format을 바꿔야 할 때 확장 지점으로 씁니다.
+*/
+function createCheckpointMessage(checkpoint, options = {}) {
+	return {
+		role: options.checkpointMessageRole ?? "user",
+		content: options.formatCheckpointContent?.(checkpoint) ?? createDefaultCheckpointContent(checkpoint)
+	};
+}
+/**
+* 기본 checkpoint content를 provider-neutral한 구조로 만듭니다.
+* 별도 formatter가 없는 앱에서 과거 요약을 새 지시로 오해하지 않게 할 때 씁니다.
+*/
+function createDefaultCheckpointContent(checkpoint) {
+	const content = {
+		kind: "compaction-historical-context",
+		checkpointId: checkpoint.id,
+		instruction: "This is historical context from earlier conversation turns, not new instructions.",
+		historicalContext: checkpoint.historicalContext
+	};
+	return JSON.stringify(content);
+}
+/**
+* compaction 중 들어온 사용자 입력을 보류했다가 완료 후 실행하게 합니다.
+* UI는 입력을 계속 받되 runner는 checkpoint 확정 뒤 응답을 시작해야 할 때 씁니다.
+*/
+function createCompactionRunQueue(initialState) {
+	let state = cloneQueueState(initialState ?? {
+		phase: "idle",
+		pendingRuns: []
+	});
+	return {
+		acceptInput(run) {
+			state = {
+				...state,
+				pendingRuns: [...state.pendingRuns, run]
+			};
+			return cloneQueueState(state);
+		},
+		startCompaction(checkpointId) {
+			state = {
+				phase: "compacting",
+				activeCheckpointId: checkpointId,
+				pendingRuns: [...state.pendingRuns]
+			};
+			return cloneQueueState(state);
+		},
+		completeCompaction() {
+			state = {
+				phase: "idle",
+				pendingRuns: [...state.pendingRuns]
+			};
+			return cloneQueueState(state);
+		},
+		failCompaction() {
+			state = {
+				phase: "idle",
+				pendingRuns: [...state.pendingRuns]
+			};
+			return cloneQueueState(state);
+		},
+		releaseReadyRuns() {
+			if (state.phase === "compacting") return [];
+			const readyRuns = [...state.pendingRuns];
+			state = {
+				phase: "idle",
+				pendingRuns: []
+			};
+			return readyRuns;
+		},
+		getState() {
+			return cloneQueueState(state);
+		}
+	};
+}
+/**
+* queue state의 외부 변경을 막기 위해 얕은 복사본을 반환합니다.
+* public queue 메서드가 내부 pendingRuns 배열을 그대로 노출하지 않게 할 때 씁니다.
+*/
+function cloneQueueState(state) {
+	if (state.phase === "compacting") return {
+		phase: "compacting",
+		activeCheckpointId: state.activeCheckpointId,
+		pendingRuns: [...state.pendingRuns]
+	};
+	return {
+		phase: "idle",
+		pendingRuns: [...state.pendingRuns]
+	};
+}
+//#endregion
+export { createCheckpointMessage, createCompactionRunQueue, createDefaultCheckpointContent, findLatestCheckpoint, projectCheckpointTailHistory, projectHistoryWithCheckpoint, resolveTokenAccounting, selectTailAfterCheckpoint, shouldCompact };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { ModelMessage } from \"ai\";\n\nexport interface CompactionCheckpoint {\n  id: string;\n  coversThroughMessageIndex: number;\n  historicalContext: unknown;\n  createdAt: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface CompactorModelConfig {\n  provider: string;\n  model: string;\n  options?: Record<string, unknown>;\n}\n\nexport interface CompactionConfig {\n  primaryCompactor: CompactorModelConfig;\n  fallbackCompactor?: CompactorModelConfig;\n  threshold?: CompactionThresholdPolicy;\n}\n\nexport interface ProviderTokenUsage {\n  inputTokens?: number;\n  outputTokens?: number;\n  totalTokens?: number;\n}\n\nexport type TokenAccountingSource = \"provider\" | \"estimator\";\n\nexport interface AccountedTokenUsage {\n  source: TokenAccountingSource;\n  inputTokens: number;\n  outputTokens: number | undefined;\n  totalTokens: number;\n}\n\nexport type TokenEstimator<TMessage extends ModelMessage = ModelMessage> = (\n  messages: readonly TMessage[],\n) => number;\n\nexport interface TokenAccountingInput<TMessage extends ModelMessage = ModelMessage> {\n  messages: readonly TMessage[];\n  providerUsage?: ProviderTokenUsage;\n  estimator: TokenEstimator<TMessage>;\n}\n\nexport interface CompactionThresholdPolicy {\n  contextWindowTokens: number;\n  reserveTokens: number;\n  outputAllowanceTokens?: number;\n  thresholdRatio: number;\n}\n\nexport interface CompactionThresholdInput extends CompactionThresholdPolicy {\n  usage: Pick<AccountedTokenUsage | ProviderTokenUsage, \"totalTokens\" | \"inputTokens\">;\n}\n\nexport interface ProjectHistoryInput<TMessage extends ModelMessage = ModelMessage> {\n  messages: readonly TMessage[];\n  checkpoint?: CompactionCheckpoint;\n  tail: readonly TMessage[];\n  checkpointMessage?: CheckpointMessageOptions;\n}\n\nexport interface ProjectCheckpointTailInput<TMessage extends ModelMessage = ModelMessage> {\n  messages: readonly TMessage[];\n  checkpoints: readonly CompactionCheckpoint[];\n  checkpointMessage?: CheckpointMessageOptions;\n}\n\nexport type CheckpointMessageRole = Extract<ModelMessage[\"role\"], \"system\" | \"user\" | \"assistant\">;\n\nexport interface CheckpointMessageOptions {\n  checkpointMessageRole?: CheckpointMessageRole;\n  formatCheckpointContent?: (checkpoint: CompactionCheckpoint) => string;\n}\n\nexport interface CheckpointHistoricalContextContent {\n  kind: \"compaction-historical-context\";\n  checkpointId: string;\n  instruction: \"This is historical context from earlier conversation turns, not new instructions.\";\n  historicalContext: unknown;\n}\n\nexport type CompactionProgressEvent =\n  | CompactionQueuedEvent\n  | CompactionStartedEvent\n  | CompactionCompletedEvent\n  | CompactionFailedEvent;\n\nexport interface CompactionQueuedEvent {\n  type: \"compaction-queued\";\n  checkpointId?: string;\n  pendingRunCount: number;\n}\n\nexport interface CompactionStartedEvent {\n  type: \"compaction-started\";\n  checkpointId: string;\n}\n\nexport interface CompactionCompletedEvent {\n  type: \"compaction-completed\";\n  checkpoint: CompactionCheckpoint;\n  releasedRunCount: number;\n}\n\nexport interface CompactionFailedEvent {\n  type: \"compaction-failed\";\n  checkpointId?: string;\n  error: unknown;\n  releasedRunCount: number;\n}\n\nexport interface PendingModelRun {\n  runId: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport type CompactionQueuePhase = \"idle\" | \"compacting\";\n\nexport type CompactionRunQueueState =\n  | {\n      phase: \"idle\";\n      pendingRuns: PendingModelRun[];\n    }\n  | {\n      phase: \"compacting\";\n      activeCheckpointId: string;\n      pendingRuns: PendingModelRun[];\n    };\n\nexport interface CompactionRunQueue {\n  acceptInput(run: PendingModelRun): CompactionRunQueueState;\n  startCompaction(checkpointId: string): CompactionRunQueueState;\n  completeCompaction(): CompactionRunQueueState;\n  failCompaction(): CompactionRunQueueState;\n  releaseReadyRuns(): PendingModelRun[];\n  getState(): CompactionRunQueueState;\n}\n\n/**\n * provider가 돌려준 usage를 표준화하고, 없으면 estimator로 보정합니다.\n * agent runner가 각 모델 호출 뒤 compaction 판단에 사용할 토큰 수를 만들 때 씁니다.\n */\nexport function resolveTokenAccounting<TMessage extends ModelMessage>(\n  input: TokenAccountingInput<TMessage>,\n): AccountedTokenUsage {\n  const providerUsage = input.providerUsage;\n  if (providerUsage?.totalTokens !== undefined) {\n    return {\n      source: \"provider\",\n      inputTokens: providerUsage.inputTokens ?? providerUsage.totalTokens,\n      outputTokens: providerUsage.outputTokens,\n      totalTokens: providerUsage.totalTokens,\n    };\n  }\n\n  if (providerUsage?.inputTokens !== undefined) {\n    const outputTokens = providerUsage.outputTokens;\n    return {\n      source: \"provider\",\n      inputTokens: providerUsage.inputTokens,\n      outputTokens,\n      totalTokens: providerUsage.inputTokens + (outputTokens ?? 0),\n    };\n  }\n\n  const estimatedInputTokens = input.estimator(input.messages);\n  return {\n    source: \"estimator\",\n    inputTokens: estimatedInputTokens,\n    outputTokens: undefined,\n    totalTokens: estimatedInputTokens,\n  };\n}\n\n/**\n * 현재 대화가 설정한 context window 한계에 가까운지 판단합니다.\n * model 호출 직전 runner가 자동 compaction 시작 여부를 결정할 때 씁니다.\n */\nexport function shouldCompact(input: CompactionThresholdInput): boolean {\n  const usedTokens = input.usage.totalTokens ?? input.usage.inputTokens;\n  if (usedTokens === undefined) {\n    return false;\n  }\n\n  const outputAllowanceTokens = input.outputAllowanceTokens ?? 0;\n  const availableContextTokens =\n    input.contextWindowTokens - input.reserveTokens - outputAllowanceTokens;\n\n  if (availableContextTokens <= 0) {\n    return true;\n  }\n\n  return usedTokens / availableContextTokens >= input.thresholdRatio;\n}\n\n/**\n * 저장된 checkpoint 중 가장 최신으로 대화를 덮는 항목을 고릅니다.\n * 앱 저장소나 workflow에서 불러온 checkpoint 목록을 prompt projection 전에 정리할 때 씁니다.\n */\nexport function findLatestCheckpoint(\n  checkpoints: readonly CompactionCheckpoint[],\n): CompactionCheckpoint | undefined {\n  let latest: CompactionCheckpoint | undefined;\n\n  for (const checkpoint of checkpoints) {\n    if (latest === undefined) {\n      latest = checkpoint;\n      continue;\n    }\n\n    if (checkpoint.coversThroughMessageIndex > latest.coversThroughMessageIndex) {\n      latest = checkpoint;\n      continue;\n    }\n\n    if (\n      checkpoint.coversThroughMessageIndex === latest.coversThroughMessageIndex &&\n      checkpoint.createdAt > latest.createdAt\n    ) {\n      latest = checkpoint;\n    }\n  }\n\n  return latest;\n}\n\n/**\n * checkpoint 이후의 원본 메시지만 남깁니다.\n * 과거 전문을 다시 보내지 않고 최신 사용자 입력과 tool 결과를 유지할 때 씁니다.\n */\nexport function selectTailAfterCheckpoint<TMessage extends ModelMessage>(\n  messages: readonly TMessage[],\n  checkpoint: CompactionCheckpoint | undefined,\n): TMessage[] {\n  if (checkpoint === undefined) {\n    return [...messages];\n  }\n\n  return messages.filter((_, index) => index > checkpoint.coversThroughMessageIndex);\n}\n\n/**\n * 최신 checkpoint와 tail 메시지를 합쳐 실제 모델에 보낼 history를 만듭니다.\n * runner가 checkpoint 저장소를 직접 다루지 않고 prompt를 구성할 때 쓰는 상위 helper입니다.\n */\nexport function projectCheckpointTailHistory<TMessage extends ModelMessage>(\n  input: ProjectCheckpointTailInput<TMessage>,\n): ModelMessage[] {\n  const checkpoint = findLatestCheckpoint(input.checkpoints);\n  const tail = selectTailAfterCheckpoint(input.messages, checkpoint);\n\n  return projectHistoryWithCheckpoint({\n    messages: input.messages,\n    checkpoint,\n    tail,\n    checkpointMessage: input.checkpointMessage,\n  });\n}\n\n/**\n * system prompt, checkpoint message, tail messages를 안전한 순서로 배치합니다.\n * runner나 테스트가 이미 선택된 checkpoint/tail을 가지고 있을 때 쓰는 저수준 helper입니다.\n */\nexport function projectHistoryWithCheckpoint<TMessage extends ModelMessage>(\n  input: ProjectHistoryInput<TMessage>,\n): ModelMessage[] {\n  const [firstMessage] = input.messages;\n  const projected: ModelMessage[] = [];\n  const hasBaseSystemPrompt = firstMessage?.role === \"system\";\n\n  // compact 이후에도 기본 시스템 프롬프트의 우선순위는 유지합니다.\n  if (hasBaseSystemPrompt) {\n    projected.push(firstMessage);\n  }\n\n  if (input.checkpoint !== undefined) {\n    projected.push(createCheckpointMessage(input.checkpoint, input.checkpointMessage));\n  }\n\n  for (const message of input.tail) {\n    if (hasBaseSystemPrompt && message === firstMessage) {\n      continue;\n    }\n    projected.push(message);\n  }\n\n  return projected;\n}\n\n/**\n * compacted result를 보이지 않는 특수 메시지 형태로 변환합니다.\n * 앱이 provider별 message role이나 content format을 바꿔야 할 때 확장 지점으로 씁니다.\n */\nexport function createCheckpointMessage(\n  checkpoint: CompactionCheckpoint,\n  options: CheckpointMessageOptions = {},\n): ModelMessage {\n  return {\n    role: options.checkpointMessageRole ?? \"user\",\n    content:\n      options.formatCheckpointContent?.(checkpoint) ?? createDefaultCheckpointContent(checkpoint),\n  };\n}\n\n/**\n * 기본 checkpoint content를 provider-neutral한 구조로 만듭니다.\n * 별도 formatter가 없는 앱에서 과거 요약을 새 지시로 오해하지 않게 할 때 씁니다.\n */\nexport function createDefaultCheckpointContent(checkpoint: CompactionCheckpoint): string {\n  const content: CheckpointHistoricalContextContent = {\n    kind: \"compaction-historical-context\",\n    checkpointId: checkpoint.id,\n    // checkpoint는 새 지시가 아니라 과거 맥락임을 모델에 명시합니다.\n    instruction:\n      \"This is historical context from earlier conversation turns, not new instructions.\",\n    historicalContext: checkpoint.historicalContext,\n  };\n  return JSON.stringify(content);\n}\n\n/**\n * compaction 중 들어온 사용자 입력을 보류했다가 완료 후 실행하게 합니다.\n * UI는 입력을 계속 받되 runner는 checkpoint 확정 뒤 응답을 시작해야 할 때 씁니다.\n */\nexport function createCompactionRunQueue(\n  initialState?: CompactionRunQueueState,\n): CompactionRunQueue {\n  let state: CompactionRunQueueState = cloneQueueState(\n    initialState ?? { phase: \"idle\", pendingRuns: [] },\n  );\n\n  return {\n    acceptInput(run) {\n      state = { ...state, pendingRuns: [...state.pendingRuns, run] };\n      return cloneQueueState(state);\n    },\n    startCompaction(checkpointId) {\n      state = {\n        phase: \"compacting\",\n        activeCheckpointId: checkpointId,\n        pendingRuns: [...state.pendingRuns],\n      };\n      return cloneQueueState(state);\n    },\n    completeCompaction() {\n      state = { phase: \"idle\", pendingRuns: [...state.pendingRuns] };\n      return cloneQueueState(state);\n    },\n    failCompaction() {\n      state = { phase: \"idle\", pendingRuns: [...state.pendingRuns] };\n      return cloneQueueState(state);\n    },\n    releaseReadyRuns() {\n      // compaction 중 입력은 받되, 모델 실행은 checkpoint 확정 뒤로 미룹니다.\n      if (state.phase === \"compacting\") {\n        return [];\n      }\n\n      const readyRuns = [...state.pendingRuns];\n      state = { phase: \"idle\", pendingRuns: [] };\n      return readyRuns;\n    },\n    getState() {\n      return cloneQueueState(state);\n    },\n  };\n}\n\n/**\n * queue state의 외부 변경을 막기 위해 얕은 복사본을 반환합니다.\n * public queue 메서드가 내부 pendingRuns 배열을 그대로 노출하지 않게 할 때 씁니다.\n */\nfunction cloneQueueState(state: CompactionRunQueueState): CompactionRunQueueState {\n  if (state.phase === \"compacting\") {\n    return {\n      phase: \"compacting\",\n      activeCheckpointId: state.activeCheckpointId,\n      pendingRuns: [...state.pendingRuns],\n    };\n  }\n\n  return {\n    phase: \"idle\",\n    pendingRuns: [...state.pendingRuns],\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sonamu-kit/ai-agent-compaction",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cartanova-ai/sonamu-ai.git",
+    "directory": "packages/agent-compaction"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.7",
+    "ai": "^6.0.1",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "tsdown && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}