@ynhcj/xiaoyi-channel 0.0.217-beta → 0.0.218-next

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { definePluginEntry } from "openclaw/plugin-sdk/core";
-declare const pluginEntry: ReturnType<typeof definePluginEntry>;
-export default pluginEntry;
+import { type OpenClawPluginDefinition } from "openclaw/plugin-sdk/core";
+declare const plugin: OpenClawPluginDefinition;
+export default plugin;

package/dist/index.js

@@ -1,7 +1,9 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { xiaoyiProvider } from "./src/provider.js";
+import { xiaoyiCompactionProvider } from "./src/compaction-provider.js";
 import { xyPlugin } from "./src/channel.js";
 import registerSentinelHook from "./src/cspl/sentinel_hook.js";
+import registerSkillScopeHook from "./src/cspl/skill_scope_hook.js";
 import { setXYRuntime } from "./src/runtime.js";
 import { markCronToolCall, clearCronToolCall, getCurrentSessionContext } from "./src/tools/session-manager.js";
 import { configManager } from "./src/utils/config-manager.js";
@@ -11,7 +13,10 @@ import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 import { registerCLIHook } from "./src/tools/hmos-cli.js";
+import { recoverCronState } from "./src/cron-recovery.js";
 import { writeSkillUsage } from "./src/utils/skills-logger.js";
+import { markSubagentSpawned, markSubagentEnded, getCachedXYConfig, } from "./src/subagent-wait-state.js";
+import { logger } from "./src/utils/logger.js";
 /**
  * Parse a file path string to detect if it refers to a SKILL.md file within
  * a skills directory. Returns the skill name (parent directory) if so.
@@ -205,7 +210,121 @@ function readJobIdFromResult(result) {
     }
     return undefined;
 }
+// ── Gateway startup: cron state recovery ────────────────────────────────────
+/**
+ * Register the gateway_start hook for cron state recovery.
+ *
+ * On gateway startup, checks .openclaw/cron/ for legacy JSON/JSONL files
+ * and migrates them into the SQLite state database:
+ *  - Reads legacy jobs.json + jobs-state.json → imports into cron_jobs table
+ *  - Reads legacy runs/*.jsonl → imports into cron_run_logs table
+ *  - Archives migrated files with .migrated suffix
+ *
+ * Pattern follows legacy-store-migration.ts and legacy-run-log-migration.ts:
+ * check → load → import into SQLite → archive old files.
+ */
+function registerCronRecoveryHook(api) {
+    api.on("gateway_start", async (_event, _ctx) => {
+        const logTag = "[CRON-RECOVERY-HOOK]";
+        const startTime = Date.now();
+        logger.log(`${logTag} ═══════════════════════════════════════════`);
+        logger.log(`${logTag} gateway_start fired — checking for legacy cron files`);
+        logger.log(`${logTag} Timestamp: ${new Date().toISOString()}`);
+        logger.log(`${logTag} Plugin registration mode: ${api.registrationMode ?? "unknown"}`);
+        let result;
+        try {
+            result = await recoverCronState();
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            const errStack = err instanceof Error ? err.stack : undefined;
+            logger.error(`${logTag} cron state recovery threw: ${errMsg}`);
+            if (errStack)
+                logger.error(`${logTag} Stack: ${errStack}`);
+            // Don't let a recovery failure block gateway startup.
+            logger.log(`${logTag} Recovery failed after ${Date.now() - startTime}ms — gateway startup continues`);
+            return;
+        }
+        const elapsed = Date.now() - startTime;
+        if (result.recovered) {
+            logger.log(`${logTag} ✅ Migration performed successfully in ${elapsed}ms:` +
+                ` storeMigrated=${result.storeMigrated}, ` +
+                ` runLogFilesImported=${result.runLogFilesImported}`);
+        }
+        else {
+            logger.log(`${logTag} ℹ️ No legacy cron files migrated in ${elapsed}ms ` +
+                `(nothing to migrate or database unavailable)`);
+        }
+        // Log diagnostics summary
+        const warnings = result.diagnostics.filter((d) => d.includes("skipping") || d.includes("locked") || d.includes("unavailable"));
+        const errors = result.diagnostics.filter((d) => d.includes("error") || d.includes("failed") || d.includes("Failed"));
+        if (warnings.length > 0) {
+            logger.warn(`${logTag} ${warnings.length} warning(s) from migration:`);
+            for (const w of warnings) {
+                logger.warn(`${logTag}   ⚠ ${w}`);
+            }
+        }
+        if (errors.length > 0) {
+            logger.error(`${logTag} ${errors.length} error(s) from migration:`);
+            for (const e of errors) {
+                logger.error(`${logTag}   ✗ ${e}`);
+            }
+        }
+        if (warnings.length === 0 && errors.length === 0) {
+            logger.log(`${logTag} All diagnostics clean, no warnings or errors`);
+        }
+        logger.log(`${logTag} ═══════════════════════════════════════════`);
+    });
+}
+function registerSubagentHooks(api) {
+    // subagent_spawned: fires after a subagent run is successfully registered.
+    // We increment the expected completion count so that onIdle knows to wait.
+    api.on("subagent_spawned", async (_event, ctx) => {
+        const requesterSessionKey = ctx?.requesterSessionKey;
+        if (!requesterSessionKey)
+            return;
+        const count = markSubagentSpawned(requesterSessionKey);
+        if (count > 0) {
+            logger.log(`[XY-SUBAGENT] spawned, requesterSessionKey=${requesterSessionKey.slice(0, 30)}, expected=${count}`);
+        }
+    });
+    // subagent_ended: fires when a subagent run terminates (complete/error/killed).
+    // This is the PRIMARY delivery tracking mechanism. When all expected
+    // subagents have ended and parent has settled, we finalize the A2A session.
+    api.on("subagent_ended", async (event, ctx) => {
+        try {
+            const requesterSessionKey = ctx?.requesterSessionKey;
+            if (!requesterSessionKey) {
+                logger.log(`[XY-SUBAGENT-END] no requesterSessionKey in ctx`);
+                return;
+            }
+            const transition = markSubagentEnded(requesterSessionKey);
+            logger.log(`[XY-SUBAGENT-END] ended, targetSessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, complete=${transition?.isComplete ?? false}, shouldFinalize=${transition?.shouldFinalize ?? false}, transition=${!!transition}`);
+            if (transition?.shouldFinalize) {
+                logger.log(`[XY-SUBAGENT-END] Starting finalization...`);
+                const config = getCachedXYConfig();
+                if (!config) {
+                    logger.error(`[XY-SUBAGENT-END] No cached XY config, cannot deliver final result`);
+                    return;
+                }
+                const { deliverSubagentFinalResult } = await import("./src/outbound.js");
+                logger.log(`[XY-SUBAGENT-END] Using cached XY config`);
+                await deliverSubagentFinalResult({
+                    config: config,
+                    state: transition.state,
+                    reason: "all-subagents-ended-after-parent-settled",
+                });
+                logger.log(`[XY-SUBAGENT-END] Finalized A2A session after all subagents ended`);
+            }
+        }
+        catch (err) {
+            logger.error(`[XY-SUBAGENT-END] Error in subagent_ended hook:`, err);
+        }
+    });
+}
 function registerFullHooks(api) {
+    // SUBAGENT HOOKS: track subagent spawn/end lifecycle for session keep-alive
+    registerSubagentHooks(api);
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};
     const skillRetrieverConfig = normalizeToolRetrieverConfig({
@@ -216,10 +335,13 @@ function registerFullHooks(api) {
         timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
     });
     const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
-    api.on("before_prompt_build", beforePromptBuildHandler);
+    api.on("before_prompt_build", async (event, ctx) => {
+        logger.log(`[BEFORE_PROMPT_BUILD] hook fired, sessionKey=${ctx.sessionKey || "undefined"}, sessionId=${ctx.sessionId || "undefined"}`);
+        return beforePromptBuildHandler(event, ctx);
+    });
     registerSelfEvolutionToolResultNudge(api);
 }
-const pluginEntry = definePluginEntry({
+const plugin = definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
     description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
@@ -227,6 +349,10 @@ const pluginEntry = definePluginEntry({
         // Always register the provider so wrapStreamFn/prepareExtraParams work
         // in ALL registration modes (not just "full").
         api.registerProvider(xiaoyiProvider);
+        // Register the compaction provider so openclaw's safeguard hook uses
+        // our summarization path (which injects x-hag-trace-id) instead of the
+        // built-in LLM path that bypasses wrapStreamFn.
+        api.registerCompactionProvider(xiaoyiCompactionProvider);
         if (api.registrationMode === "cli-metadata") {
             return;
         }
@@ -244,13 +370,17 @@ const pluginEntry = definePluginEntry({
             registerFullHooks(api);
             // CSPL sentinel hook: before_tool_call + after_tool_call security scanning
             registerSentinelHook(api);
+            // CSPL skill scope hook: before_install security scanning
+            registerSkillScopeHook(api);
             // Cron detection hook: marks toolCallIds from cron sessions
             registerCronDetectionHook(api);
             // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools
             registerCLIHook(api);
+            // Cron recovery hook: prunes stale cron-push-map and pushData on gateway startup
+            registerCronRecoveryHook(api);
             // Skills diagnostic hook: log skill usage (detected via SKILL.md reads)
             registerSkillsDiagnosticHook(api);
         }
     },
 });
-export default pluginEntry;
+export default plugin;

package/dist/src/bot.js

@@ -15,7 +15,9 @@ import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { saveRuntimeInfo } from "./utils/runtime-manager.js";
 import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
 import { setCsplSteerContext } from "./cspl/steer-context.js";
+import { resolveActiveEmbeddedRunSessionId, queueAgentHarnessMessage, } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { registerTaskId, decrementTaskIdRef, hasActiveTask, } from "./task-manager.js";
+import { registerSessionKeyMapping, getWaitState, hasWaitState, markParentSettled, cacheXYConfig, } from "./subagent-wait-state.js";
 import { logger } from "./utils/logger.js";
 /**
  * Handle an incoming A2A message.
@@ -164,6 +166,7 @@ export async function handleXYMessage(params) {
         const runCrossTaskContext = extractRunCrossTaskContext(parsed.parts);
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
+        cacheXYConfig(config);
         // ✅ Resolve agent route (following feishu pattern)
         // accountId is "default" for XY (single account mode)
         // Use sessionId as peer.id to ensure all messages in the same session share context
@@ -177,6 +180,16 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
+        // Register sessionKey→A2A sessionId mapping for subagent hook translation.
+        // Hooks receive openclaw sessionKey (e.g. "agent:main:direct:xxx") but
+        // xy_channel operates on A2A sessionId. This bridge lets subagent_spawned/
+        // subagent_ended hooks find the correct wait state.
+        // IMPORTANT: Only register on the FIRST message. Steer messages have a
+        // different taskId — overwriting the mapping would break subagent wait
+        // state tracking for the original message's subagents.
+        if (!isUpdate) {
+            registerSessionKeyMapping(route.sessionKey, parsed.sessionId, parsed.taskId, parsed.messageId);
+        }
         // Check for ACP runtime binding on this A2A conversation
         const runtimeRoute = resolveRuntimeConversationBindingRoute({
             route,
@@ -241,20 +254,18 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
-            if (!isUpdate) {
-                log.log(`[BOT] Sending initial status update`);
-                void sendStatusUpdate({
-                    config,
-                    sessionId: parsed.sessionId,
-                    taskId: parsed.taskId,
-                    messageId: parsed.messageId,
-                    text: "任务正在处理中，请稍候~",
-                    state: "working",
-                }).catch((err) => {
-                    log.error(`Failed to send initial status update:`, err);
-                });
-            }
+            // 🔑 发送初始状态更新
+            log.log(`[BOT] Sending initial status update`);
+            void sendStatusUpdate({
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                text: "任务正在处理中，请稍候~",
+                state: "working",
+            }).catch((err) => {
+                log.error(`Failed to send initial status update:`, err);
+            });
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -280,10 +291,8 @@ export async function handleXYMessage(params) {
             }
         }
         // ── Build message and dispatch via auto-reply pipeline ──────────
-        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
-        // detects active runs and handles steer injection natively — the channel
-        // does not need its own steer detection or polling logic.
-        // File download
+        // 首条消息和 steer 回退都走此统一 dispatch 路径。
+        // File download — for both first message and steer fallthrough
         let mediaPayload = {};
         if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
@@ -299,13 +308,35 @@ export async function handleXYMessage(params) {
             textForAgent = `${textForAgent}${fileHint}`;
             log.log(`[BOT] Steer: appended file paths to text`);
         }
+        // 🔑 Direct steer: bypass dispatchReplyFromConfig entirely and inject the
+        // message directly into the active embedded agent run. This avoids the
+        // per-session ReplyOperation lock in admitReplyTurn which would otherwise
+        // block the steer message until the first message completes — making steer
+        // indistinguishable from a followup.
+        if (isUpdate && !skipReg && route.sessionKey) {
+            const activeSessionId = resolveActiveEmbeddedRunSessionId(route.sessionKey);
+            if (activeSessionId) {
+                log.log(`[BOT-STEER] Direct steer attempt: activeSessionId=${activeSessionId}, textLen=${textForAgent.length}`);
+                const queued = queueAgentHarnessMessage(activeSessionId, textForAgent, {
+                    steeringMode: "all",
+                });
+                if (queued) {
+                    log.log(`[BOT-STEER] Direct steer succeeded — message injected into active run`);
+                    // Steer message taskId refCount is no longer needed since we skip the dispatcher.
+                    decrementTaskIdRef(parsed.sessionId);
+                    return;
+                }
+                log.log(`[BOT-STEER] Direct steer failed (queued=false), falling through to dispatchReplyFromConfig`);
+            }
+            else {
+                log.log(`[BOT-STEER] No active embedded run session for key=${route.sessionKey}, falling through to dispatchReplyFromConfig`);
+            }
+        }
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
-        let messageBody = textForAgent;
-        // Add speaker prefix for clarity
         const speaker = parsed.sessionId;
-        messageBody = `${speaker}: ${messageBody}`;
+        const messageBody = `${speaker}: ${textForAgent}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
             channel: "xiaoyi-channel",
@@ -314,12 +345,20 @@ export async function handleXYMessage(params) {
             envelope: envelopeOptions,
             body: messageBody,
         });
+        // 🔑 Steer messages use /steer prefix + CommandSource "native" to trigger
+        // the native slash command fast path, which calls handleSteerCommand →
+        // queueEmbeddedAgentMessageWithOutcomeAsync before admitReplyTurn blocks.
+        const steerCommandBody = isUpdate ? `/steer ${textForAgent}` : textForAgent;
+        if (isUpdate) {
+            log.log(`[BOT-STEER] Dispatching via /steer fast path, sessionKey=${route.sessionKey}, cmdLen=${steerCommandBody.length}`);
+        }
         // ✅ Finalize inbound context (following feishu pattern)
         // Use route.accountId and route.sessionKey instead of parsed fields
         const ctxPayload = core.channel.reply.finalizeInboundContext({
             Body: body,
-            RawBody: textForAgent,
-            CommandBody: textForAgent,
+            RawBody: steerCommandBody,
+            CommandBody: steerCommandBody,
+            ...(isUpdate ? { CommandSource: "native" } : {}),
             From: parsed.sessionId,
             To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
             SessionKey: route.sessionKey, // ✅ Use route.sessionKey
@@ -343,15 +382,33 @@ export async function handleXYMessage(params) {
         // response and cleanup — the first message's dispatcher handles those.
         const steerState = { steered: isUpdate };
         // 🔑 创建dispatcher
-        log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
+        log.log(`[BOT-DISPATCHER] Creating reply dispatcher, isSteer=${isUpdate}, sessionKey=${route.sessionKey}`);
         // Cleanup: 必须在 onIdle 内部执行（参见 reply-dispatcher.ts 中 onIdleComplete 的注释）
+        // CSPL steer injections (skipRegistration=true) do NOT call registerTaskId,
+        // so they must skip decrementTaskIdRef. All other paths (original message +
+        // WebSocket steer that fell through to the /steer fast path) DO increment
+        // refCount and must decrement here.
         let cleaned = false;
         const cleanup = () => {
             if (cleaned)
                 return;
             cleaned = true;
-            log.log(`[BOT] Cleanup started`);
-            decrementTaskIdRef(parsed.sessionId);
+            log.log(`[BOT] Cleanup started, steered=${steerState.steered}, skipReg=${skipReg}`);
+            if (!skipReg) {
+                // Check for pending subagent wait on this session
+                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId) ??
+                    (hasWaitState(parsed.sessionId) ? { deliveredCompletions: 0, expectedCompletions: 1 } : null);
+                if (pendingWait && pendingWait.deliveredCompletions < pendingWait.expectedCompletions) {
+                    // Subagent wait active — skip cleanup, session stays alive
+                    log.log(`[BOT] Cleanup suppressed — subagent wait active on session, taskId=${parsed.taskId}`);
+                    cleaned = false;
+                    return;
+                }
+                decrementTaskIdRef(parsed.sessionId);
+            }
+            else {
+                log.log(`[BOT] CSPL steer cleanup, skipping decrementTaskIdRef (never incremented)`);
+            }
             log.log(`[BOT] Cleanup completed`);
         };
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval, updateFallbackTaskId } = createXYReplyDispatcher({
@@ -388,13 +445,34 @@ export async function handleXYMessage(params) {
         log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
-            onSettled: () => {
+            onSettled: async () => {
                 log.log(`[BOT] onSettled, steered=${steerState.steered}`);
                 // 🔑 When steered, skip cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
                     log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
                     return;
                 }
+                // Subagent wait state: if parent has pending subagents, mark settled
+                // and defer finalization. Cleanup is suppressed so the session stays alive.
+                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId);
+                if (pendingWait && !pendingWait.parentSettled) {
+                    const transition = markParentSettled(parsed.sessionId, parsed.taskId);
+                    if (transition?.shouldFinalize) {
+                        // All completions arrived before parent settled → finalize now
+                        const { deliverSubagentFinalResult } = await import("./outbound.js");
+                        await deliverSubagentFinalResult({
+                            config,
+                            state: transition.state,
+                            reason: "all-subagent-results-delivered-before-parent-settled",
+                        });
+                        log.log(`[BOT] Subagent wait complete on parent settled; final response delivered`);
+                    }
+                    else {
+                        log.log(`[BOT] Subagent wait active, preserving session context for completion`);
+                    }
+                    dispatcherUpdaters.delete(parsed.sessionId);
+                    return;
+                }
                 // cleanup 已由 onIdleComplete 在 onIdle 的 finally 中执行。
                 // onSettled 不做任何清理（直接在这里清理会发生 race condition）。
                 dispatcherUpdaters.delete(parsed.sessionId);
@@ -406,7 +484,8 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=false`);
+                    const isSteerDispatch = isUpdate && !skipReg;
+                    log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
                     log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
@@ -466,19 +545,21 @@ export async function handleXYMessage(params) {
 function buildXYMediaPayload(mediaList) {
     const first = mediaList[0];
     const mediaPaths = mediaList.map((media) => media.path);
+    const mediaUrls = mediaList.map((media) => media.uri);
     const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
     return {
         MediaPath: first?.path,
         MediaType: first?.mimeType,
+        MediaUrl: first?.uri,
         MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
 // ─────────────────────────────────────────────────────────────
 // Dispatcher updaters (cross-chain taskId bridging)
 // ─────────────────────────────────────────────────────────────
-// Use globalThis to survive module deduplication — provider.ts may load a
-// different copy of bot.ts, so a plain module-level Map would be two objects.
+// Use globalThis to survive module deduplication
 const _g = globalThis;
 if (!_g.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();

package/dist/src/channel.js

@@ -28,6 +28,7 @@ import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js"
 import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
 import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
 import { invokeTool } from "./tools/invoke.js";
+import { xiaoyiAppendReferenceTool } from "./tools/xiaoyi-append-reference.js";
 const ALL_TOOLS = [
     locationTool,
     discoverCrossDevicesTool,
@@ -52,6 +53,7 @@ const ALL_TOOLS = [
     agentAsSkillTool,
     checkPluginPrivilegeTool,
     invokeTool,
+    xiaoyiAppendReferenceTool,
 ];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.

package/dist/src/compaction-provider.d.ts

@@ -0,0 +1,50 @@
+interface CompactionConfig {
+    uid: string;
+    baseUrl: string;
+    modelName: string;
+    apiKey?: string;
+}
+/**
+ * Snapshot of the resolved session context, captured from the last normal
+ * LLM request before compaction is triggered. When available, the
+ * CompactionProvider reuses the same A2A traceId/sessionId so the
+ * compaction summarization request is linked to the same user session
+ * in backend tracing.
+ */
+interface CompactionSessionSnapshot {
+    traceId: string;
+    sessionId: string;
+    interactionId: string;
+    deviceType?: string;
+    appVer?: string;
+    sdkApiVersion?: string;
+    /** Auth headers from options.headers in the last normal request. */
+    requestHeaders?: Record<string, string>;
+    /** API key from the last normal request (for Bearer token auth). */
+    apiKey?: string;
+    /** Model-level headers from resolveDynamicModel (streamSimple adds these). */
+    modelHeaders?: Record<string, string>;
+}
+/** Store config captured from prepareExtraParams so summarize() can read it. */
+export declare function setCompactionConfig(config: CompactionConfig | null): void;
+/**
+ * Store a snapshot of the resolved session headers captured from the
+ * most recent wrapStreamFn call. This lets the CompactionProvider reuse
+ * the A2A traceId/sessionId during compaction summarization.
+ */
+export declare function setCompactionSessionSnapshot(snapshot: CompactionSessionSnapshot | null): void;
+export declare const xiaoyiCompactionProvider: {
+    id: string;
+    label: string;
+    summarize(params: {
+        messages: unknown[];
+        signal?: AbortSignal;
+        customInstructions?: string;
+        summarizationInstructions?: {
+            identifierPolicy?: string;
+            identifierInstructions?: string;
+        };
+        previousSummary?: string;
+    }): Promise<string>;
+};
+export {};