@gt-fe/eap-runtime 0.0.20 → 0.0.22

package/dist/session/apply-session-compression.js

@@ -0,0 +1,281 @@
+/**
+ * execute/stream 装载历史后的压缩入口。默认关。
+ *
+ * C-1a 开关：options.enabled 或 EAP_RUNTIME_COMPRESSION=1
+ * C-1b 有窗口：用上一轮 llm_turns 的 used/window，不用字符估窗
+ * C-1c 无窗口：只按轮次上限，不按窗压
+ * C-1d 摘要只走 ILLMProvider；失败则不压缩
+ * C-1e 默认只改本轮内存历史；persistCompressed 时必须能写 compression record
+ * C-1f 流式路径在摘要前产出 session.compression.started，结束后产出 completed。
+ *      不新开「占用 ≥ 80% 再 compact」链；触发仍是 C-1b/c。
+ */
+import { EchoLLMProvider } from '../providers/echo-llm-provider.js';
+import { COMPRESSION_WINDOW_FACTOR, countRounds, DEFAULT_COMPRESSION_CONFIG, } from '../memory/message-compression.service.js';
+import { SlidingWindowCompression } from '../memory/compression/sliding-window.compression.js';
+import { emitRuntimeLog } from '../common/logger.js';
+export function isRuntimeCompressionEnabled(explicit, env = process.env) {
+    if (explicit === true)
+        return true;
+    if (explicit === false)
+        return false;
+    const raw = env.EAP_RUNTIME_COMPRESSION ?? env.EAP_COMPRESSION_ENABLED;
+    return raw === '1' || raw === 'true';
+}
+export function isRuntimeCompressionPersist(explicit, env = process.env) {
+    if (explicit === true)
+        return true;
+    if (explicit === false)
+        return false;
+    return env.EAP_RUNTIME_COMPRESSION_PERSIST === '1' || env.EAP_RUNTIME_COMPRESSION_PERSIST === 'true';
+}
+export function formatCompressionStartedMessage(input) {
+    if (typeof input.percent === 'number' && Number.isFinite(input.percent)) {
+        return `Context ${input.percent}% full. Compacting...`;
+    }
+    if (typeof input.threshold === 'number' && Number.isFinite(input.threshold)) {
+        return `Conversation exceeded ${input.threshold} rounds. Compacting...`;
+    }
+    return 'Compacting conversation history...';
+}
+export function formatCompressionCompletedMessage(input) {
+    if (!input.success) {
+        return input.error
+            ? 'Compression failed; using original history.'
+            : 'Compression skipped; using original history.';
+    }
+    return `Compressed ${input.originalMessageCount} → ${input.compressedMessageCount} messages.`;
+}
+export async function applySessionCompression(params) {
+    const result = await runSessionCompression(params);
+    return result.messages;
+}
+/** 未显式 summaryModel 时写入 Agent `models.default`。压缩未开则不解析。 */
+export async function withCompressionSummaryModel(options, resolveDefaultModel, env = process.env) {
+    if (!options)
+        return options;
+    if (!isRuntimeCompressionEnabled(options.enabled, env))
+        return options;
+    if (options.summaryModel?.trim())
+        return options;
+    const summaryModel = (await resolveDefaultModel())?.trim();
+    if (!summaryModel || summaryModel.toLowerCase() === 'default')
+        return options;
+    return { ...options, summaryModel };
+}
+/**
+ * 流式入口用：先产出 started，再跑摘要，再产出 completed，最后给出本轮历史。
+ * SDK `stream` 可在 started 之后才继续 next()，HTTP SSE 可立刻 emit。
+ */
+export async function* iterSessionCompression(params) {
+    const history = params.history ?? [];
+    const decision = await decideSessionCompression(params);
+    if (!decision.needed || !decision.started) {
+        yield { kind: 'history', messages: history };
+        return;
+    }
+    yield { kind: 'started', payload: decision.started };
+    const result = await runDecidedSessionCompression(params, decision);
+    if (result.completed) {
+        yield { kind: 'completed', payload: result.completed };
+    }
+    yield { kind: 'history', messages: result.messages };
+}
+export async function runSessionCompression(params) {
+    const decision = await decideSessionCompression(params);
+    if (!decision.needed) {
+        return { messages: params.history ?? [], compressed: false };
+    }
+    return runDecidedSessionCompression(params, decision);
+}
+export async function decideSessionCompression(params) {
+    const history = params.history ?? [];
+    const originalMessageCount = history.length;
+    const options = params.options ?? {};
+    const env = params.env ?? process.env;
+    const enabled = isRuntimeCompressionEnabled(options.enabled, env);
+    if (!enabled || history.length === 0) {
+        return { needed: false, originalMessageCount };
+    }
+    const provider = options.provider;
+    if (!provider || provider instanceof EchoLLMProvider) {
+        return { needed: false, originalMessageCount };
+    }
+    const maxRounds = options.maxRounds ?? DEFAULT_COMPRESSION_CONFIG.maxRounds;
+    const last = await lastTurnUsage(options.turnLog, params.sessionId);
+    const needed = last?.window
+        ? last.used >= Math.floor(last.window * COMPRESSION_WINDOW_FACTOR)
+        : countRounds(history) > maxRounds;
+    if (!needed) {
+        return { needed: false, originalMessageCount };
+    }
+    const reason = last?.window ? 'window' : 'max_rounds';
+    const percent = last?.window && last.window > 0 ? Math.round((last.used / last.window) * 100) : undefined;
+    const threshold = last?.window
+        ? Math.floor(last.window * COMPRESSION_WINDOW_FACTOR)
+        : maxRounds;
+    const started = {
+        sessionId: params.sessionId,
+        ...(params.taskId ? { taskId: params.taskId } : {}),
+        reason,
+        originalMessageCount,
+        ...(last ? { used: last.used } : {}),
+        ...(last?.window ? { window: last.window } : {}),
+        ...(percent !== undefined ? { percent } : {}),
+        threshold,
+        displayMessage: formatCompressionStartedMessage({ percent, reason, threshold }),
+    };
+    return {
+        needed: true,
+        originalMessageCount,
+        reason,
+        used: last?.used,
+        window: last?.window,
+        percent,
+        threshold,
+        started,
+    };
+}
+async function runDecidedSessionCompression(params, decision) {
+    const history = params.history ?? [];
+    const options = params.options ?? {};
+    const env = params.env ?? process.env;
+    const provider = options.provider;
+    if (!provider || provider instanceof EchoLLMProvider || !decision.needed) {
+        return {
+            messages: history,
+            compressed: false,
+            completed: completedPayload(params, decision, {
+                success: false,
+                compressedMessageCount: history.length,
+                persisted: false,
+            }),
+        };
+    }
+    const persist = isRuntimeCompressionPersist(options.persistCompressed, env);
+    if (persist && !options.compressionRepository) {
+        emitRuntimeLog('warn', 'runtime.compression', 'persist requested without repository; memory only', {
+            event: 'runtime.compression.persist_skipped',
+            sessionId: params.sessionId,
+        });
+    }
+    const maxRounds = options.maxRounds ?? DEFAULT_COMPRESSION_CONFIG.maxRounds;
+    try {
+        const compression = new SlidingWindowCompression({
+            maxRounds,
+            preserveRecentRounds: options.preserveRecentRounds ?? DEFAULT_COMPRESSION_CONFIG.preserveRecentRounds,
+            ...(decision.window ? { maxContextTokens: decision.window } : {}),
+        }, async (msgs) => summarizeWithProvider(provider, msgs, options.summaryModel));
+        const compressed = await compression.compress(history);
+        if (compressed === history) {
+            return {
+                messages: history,
+                compressed: false,
+                completed: completedPayload(params, decision, {
+                    success: false,
+                    compressedMessageCount: history.length,
+                    persisted: false,
+                }),
+            };
+        }
+        const record = {
+            sessionId: params.sessionId,
+            taskId: params.taskId ?? null,
+            originalMessageCount: history.length,
+            compressedMessageCount: compressed.length,
+            originalTokens: decision.used ?? 0,
+            compressedTokens: 0,
+            strategy: 'sliding-window',
+            summaryContent: compressed[0]?.content ?? '',
+            createdBy: params.userId ?? 'system',
+            createdAt: new Date().toISOString(),
+        };
+        let persisted = false;
+        if (persist && options.compressionRepository) {
+            await options.compressionRepository.save(record);
+            persisted = true;
+        }
+        return {
+            messages: compressed,
+            compressed: true,
+            record,
+            completed: completedPayload(params, decision, {
+                success: true,
+                compressedMessageCount: compressed.length,
+                persisted,
+            }),
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        emitRuntimeLog('warn', 'runtime.compression', 'compress failed; using original history', {
+            event: 'runtime.compression.failed',
+            sessionId: params.sessionId,
+            error,
+        });
+        return {
+            messages: history,
+            compressed: false,
+            completed: completedPayload(params, decision, {
+                success: false,
+                compressedMessageCount: history.length,
+                persisted: false,
+                error,
+            }),
+        };
+    }
+}
+function completedPayload(params, decision, outcome) {
+    const reason = decision.reason ?? 'max_rounds';
+    return {
+        sessionId: params.sessionId,
+        ...(params.taskId ? { taskId: params.taskId } : {}),
+        reason,
+        success: outcome.success,
+        originalMessageCount: decision.originalMessageCount,
+        compressedMessageCount: outcome.compressedMessageCount,
+        ...(decision.used !== undefined ? { used: decision.used } : {}),
+        ...(decision.window !== undefined ? { window: decision.window } : {}),
+        ...(decision.percent !== undefined ? { percent: decision.percent } : {}),
+        persisted: outcome.persisted,
+        ...(outcome.error ? { error: outcome.error } : {}),
+        displayMessage: formatCompressionCompletedMessage({
+            success: outcome.success,
+            originalMessageCount: decision.originalMessageCount,
+            compressedMessageCount: outcome.compressedMessageCount,
+            error: outcome.error,
+        }),
+    };
+}
+async function lastTurnUsage(turnLog, sessionId) {
+    if (!turnLog || !sessionId)
+        return undefined;
+    const index = await turnLog.list(sessionId);
+    const last = index[index.length - 1];
+    if (!last || typeof last.used !== 'number')
+        return undefined;
+    return { used: last.used, window: last.window };
+}
+async function summarizeWithProvider(provider, messages, summaryModel) {
+    const body = messages
+        .map((m) => `${m.role}: ${m.content}`)
+        .join('\n')
+        .slice(0, 12000);
+    const raw = summaryModel?.trim();
+    const model = raw && raw.toLowerCase() !== 'default' ? raw : '';
+    const response = await provider.invoke([
+        {
+            role: 'system',
+            content: '将对话历史压成短摘要，保留用户需求、结论和未完成事项。',
+        },
+        { role: 'user', content: body },
+    ], {
+        model,
+        temperature: 0.2,
+        maxTokens: 1024,
+    });
+    const text = response.content?.trim();
+    if (!text) {
+        throw new Error('empty compression summary');
+    }
+    return text;
+}

package/dist/session/apply-session-memory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * execute/stream 装载历史后注入长期记忆。默认关。
+ * 只用关键词匹配；未注入真实 embedding 不做向量检索。
+ */
+import type { GraphMessage } from '../graph/contracts/executable-graph.js';
+import { LongTermMemoryService, type MemoryRecord } from '../memory/long-term-memory.service.js';
+export interface SessionMemoryOptions {
+    enabled?: boolean;
+    service?: LongTermMemoryService;
+    limit?: number;
+}
+export declare function isRuntimeMemoryEnabled(explicit?: boolean, env?: NodeJS.ProcessEnv): boolean;
+export declare function applySessionMemory(params: {
+    history: GraphMessage[];
+    userId?: string;
+    agentCode?: string;
+    query?: string;
+    options?: SessionMemoryOptions;
+    env?: NodeJS.ProcessEnv;
+}): Promise<GraphMessage[]>;
+export declare function injectMemoryHits(history: GraphMessage[], memories: MemoryRecord[]): GraphMessage[];

package/dist/session/apply-session-memory.js

@@ -0,0 +1,48 @@
+/**
+ * execute/stream 装载历史后注入长期记忆。默认关。
+ * 只用关键词匹配；未注入真实 embedding 不做向量检索。
+ */
+import { SemanticRetrievalService } from '../memory/semantic-retrieval.service.js';
+export function isRuntimeMemoryEnabled(explicit, env = process.env) {
+    if (explicit === true)
+        return true;
+    if (explicit === false)
+        return false;
+    const raw = env.EAP_RUNTIME_MEMORY;
+    return raw === '1' || raw === 'true';
+}
+export async function applySessionMemory(params) {
+    const history = params.history ?? [];
+    const options = params.options ?? {};
+    const env = params.env ?? process.env;
+    if (!isRuntimeMemoryEnabled(options.enabled, env))
+        return history;
+    const service = options.service;
+    if (!service || !params.userId || !params.agentCode)
+        return history;
+    const query = params.query?.trim() ||
+        [...history].reverse().find((m) => m.role === 'user')?.content?.trim() ||
+        '';
+    if (!query)
+        return history;
+    const stored = await service.retrieve(params.userId, params.agentCode, 50);
+    if (stored.length === 0)
+        return history;
+    const retrieval = new SemanticRetrievalService({
+        strategy: 'keyword',
+        limit: options.limit ?? 10,
+    });
+    const hits = await retrieval.retrieve(query, stored);
+    if (hits.length === 0)
+        return history;
+    return injectMemoryHits(history, hits.map((h) => h.record));
+}
+export function injectMemoryHits(history, memories) {
+    if (memories.length === 0)
+        return history;
+    const memoryContent = memories.map((m) => `[${m.type}] ${m.content}`).join('\n');
+    return [
+        { role: 'system', content: `[Long-term Memory]\n${memoryContent}` },
+        ...history,
+    ];
+}

package/dist/session/index.d.ts

@@ -10,4 +10,6 @@ export type { FileMessageRepositoryOptions } from './file-message.repository.js'
 export { SessionContextService } from './session-context.service.js';
 export type { ResolveSessionParams, SessionContext, } from './session-context.service.js';
 export { CompressionMiddleware, createCompressionMiddleware } from './compression-middleware.js';
+export { applySessionCompression, withCompressionSummaryModel, runSessionCompression, decideSessionCompression, iterSessionCompression, formatCompressionStartedMessage, formatCompressionCompletedMessage, isRuntimeCompressionEnabled, isRuntimeCompressionPersist, type SessionCompressionOptions, type RunSessionCompressionParams, type RunSessionCompressionResult, type SessionCompressionDecision, type SessionCompressionStep, } from './apply-session-compression.js';
 export type { CompressionMiddlewareConfig } from './compression-middleware.js';
+export { applySessionMemory, isRuntimeMemoryEnabled, type SessionMemoryOptions, } from './apply-session-memory.js';

package/dist/session/index.js

@@ -10,3 +10,5 @@ export { FileMessageRepository } from './file-message.repository.js';
 export { SessionContextService } from './session-context.service.js';
 // 压缩中间件
 export { CompressionMiddleware, createCompressionMiddleware } from './compression-middleware.js';
+export { applySessionCompression, withCompressionSummaryModel, runSessionCompression, decideSessionCompression, iterSessionCompression, formatCompressionStartedMessage, formatCompressionCompletedMessage, isRuntimeCompressionEnabled, isRuntimeCompressionPersist, } from './apply-session-compression.js';
+export { applySessionMemory, isRuntimeMemoryEnabled, } from './apply-session-memory.js';

package/dist/session/persist-turn-messages.d.ts

@@ -21,6 +21,7 @@ export declare function persistAssistantTurnMessage(messageService: MessageServi
     toolCalls?: unknown[];
     /** DeepSeek thinking：多轮回传用 */
     reasoningContent?: string;
+    durationMs?: number | null;
 }): Promise<void>;
 /**
  * HITL 等待态占位消息：避免早退时本轮只有 user、历史偏薄
@@ -46,11 +47,56 @@ export declare function persistToolTurnMessage(messageService: MessageService |
 }): Promise<void>;
 /** 从流式 RuntimeEvent payload 抽取文本增量 */
 export declare function extractStreamTextDelta(eventType: string, payload: unknown): string;
+/** 按节点分开累加 stream 文本，避免并行 LLM 的 token 交错拼成一条消息 */
+export type StreamAssistantBuckets = {
+    order: string[];
+    text: Map<string, string>;
+};
+export declare function createStreamAssistantBuckets(): StreamAssistantBuckets;
+export declare function applyStreamTextDelta(buckets: StreamAssistantBuckets, eventType: string, payload: unknown): void;
+export declare function streamAssistantTexts(buckets: StreamAssistantBuckets): Array<{
+    nodeId: string;
+    text: string;
+}>;
+/** 最后一个有文本的节点（有汇合节点时通常是它） */
+export declare function lastStreamAssistantText(buckets: StreamAssistantBuckets): string;
+/** 用户可见兜底输出：各节点文本都保留，避免无汇合时只剩后出现的一路 */
+export declare function visibleStreamAssistantText(buckets: StreamAssistantBuckets): string;
+/** `finishPoints` 里的实际节点 id；`__end__` / `__start__` 不算。空则 Session 不按结束节点筛选。 */
+export declare function namedFinishPoints(finishPoints?: string[]): string[];
+/**
+ * Session 里的助手正文。
+ * - `finishPoints` 只含一个实际节点 id（DAG `merge`）：只留该节点
+ * - 没有实际节点 id，或含多个：全部保留，由调用方拼成一条消息（规划执行的计划+结果）
+ * 不把 planner 写进 finishPoints：那会变成 LangGraph 终止点，计划跑完图就结束。
+ */
+export declare function sessionVisibleAssistantTexts(texts: Array<{
+    nodeId?: string;
+    text: string;
+}>, finishPoints?: string[]): Array<{
+    nodeId?: string;
+    text: string;
+}>;
+/**
+ * invoke 路径图增量。tool_calls / tool 行原样保留，纯文本助手收成一条放在末尾（与 stream 落库顺序一致）。
+ * GraphMessage 无 nodeId：`finishPoints` 只含一个实际节点 id 时取最后一条纯文本，不是按 id 筛选（官方 DAG 的 `merge` 在末尾）。
+ * 没有实际节点 id 或仅为 `__end__` 时把多段正文用空行拼进这一条。
+ * 无 toolCallId 的 tool 行不进 Session（code 节点结果）。
+ */
+export declare function sessionVisibleGraphMessages(messages: GraphMessage[], finishPoints?: string[]): GraphMessage[];
 /**
  * 从流式事件抽取 assistant reasoning。
  * 子图在 skill.completed 上回传（父图不再为 subgraph 节点发空 response.chunk）。
  */
 export declare function extractStreamReasoning(eventType: string, payload: unknown): string | undefined;
+/** 落盘 / 回填历史只收终态：result，或不会再试的 error。willRetry 的 error 只给直播 UI。 */
+export declare function isTerminalToolStreamEvent(eventType: string, payload: unknown): boolean;
+export declare function appendTerminalToolResult(eventType: string, payload: unknown, bucket: Array<{
+    toolCallId: string;
+    toolName: string;
+    content: unknown;
+    success: boolean;
+}>): void;
 /** 历史 MessageRecord → GraphMessage（保留 tool 元数据与 reasoning） */
 export declare function messageRecordsToGraphMessages(records: MessageRecord[]): GraphMessage[];
 /**
@@ -94,8 +140,10 @@ export declare function buildHitlWaitingTaskOutput(params: {
 /** 从 Task.output 解析 Checkpoint thread_id（含嵌套 hitl.threadId） */
 export declare function extractHitlThreadId(output: unknown): string | undefined;
 /**
- * Checkpoint thread_id 契约：HITL/多轮优先且应唯一等于 sessionId；
+ * Checkpoint 父图 thread_id：HITL/多轮优先且应唯一等于 sessionId；
  * 无 session 时退到 `task-${taskId}`。勿用 correlationId 作为 Checkpoint key。
+ * 子图槽位再经 `checkpointStorageThreadId`（`thread_id#父节点id`），
+ * 与 LangGraph put / 子图内 HITL interrupt 同一把钥匙。
  *
  * 注意：session 级 thread + 全量 Session 历史同时注入会导致 messages 双重 append。
  * 组装本轮 Graph 输入请用 {@link buildTurnGraphMessages}（有 Checkpoint 历史则只追加 user）。
@@ -124,6 +172,13 @@ export declare function buildTurnTranscriptFromStreamEvents(params: {
     pendingToolCalls?: StreamToolCall[];
     toolResults?: StreamToolResult[];
     assistantText?: string;
+    /** 按节点分开的助手文本；有值时优先于 assistantText */
+    assistantTexts?: Array<{
+        nodeId?: string;
+        text: string;
+    }>;
+    /** 图 finishPoints。只含一个实际节点 id 时按该 id 只留该节点正文；仅为 `__end__` 或含多个实际节点 id 时全部拼接 */
+    finishPoints?: string[];
     /** 带 tool_calls 的那条 assistant 的 reasoning（thinking 回传） */
     toolCallReasoningContent?: string;
     /** 最终文本 assistant 的 reasoning */
@@ -142,4 +197,5 @@ export declare function persistTurnTranscript(messageService: MessageService | u
     /** 无 assistant 文本消息时的兜底（invoke 的 graphResult.output） */
     fallbackAssistantContent?: string;
     assistantTokenCount?: number;
+    assistantDurationMs?: number | null;
 }): Promise<void>;