@wingman-ai/gateway 0.5.0 → 0.5.1

package/dist/cli/core/agentInvoker.cjs

@@ -24,27 +24,35 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    chunkSignalsActiveSummarization: ()=>chunkSignalsActiveSummarization,
+    resolveAgentMemorySources: ()=>resolveAgentMemorySources,
+    emitCompletionAndContinuePostProcessing: ()=>emitCompletionAndContinuePostProcessing,
+    buildUserContent: ()=>buildUserContent,
+    mergeTokenUsageSnapshots: ()=>mergeTokenUsageSnapshots,
+    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    detectContextSummarizationTransition: ()=>detectContextSummarizationTransition,
+    AgentInvoker: ()=>AgentInvoker,
+    configureDeepAgentSummarizationMiddleware: ()=>configureDeepAgentSummarizationMiddleware,
+    resolveHumanInTheLoopSettings: ()=>resolveHumanInTheLoopSettings,
+    isRootLangGraphTerminalEvent: ()=>isRootLangGraphTerminalEvent,
     resolveToolRetryMiddlewareSettings: ()=>resolveToolRetryMiddlewareSettings,
     resolveSummarizationMiddlewareSettings: ()=>resolveSummarizationMiddlewareSettings,
-    resolveAgentMemorySources: ()=>resolveAgentMemorySources,
+    chunkBelongsToSummarizationMiddleware: ()=>chunkBelongsToSummarizationMiddleware,
+    recompileDeepAgentWithMiddlewareOverrides: ()=>recompileDeepAgentWithMiddlewareOverrides,
+    chunkHasBuiltInSummarizationSignal: ()=>chunkHasBuiltInSummarizationSignal,
     OUTPUT_VIRTUAL_PATH: ()=>OUTPUT_VIRTUAL_PATH,
-    emitCompletionAndContinuePostProcessing: ()=>emitCompletionAndContinuePostProcessing,
     resolveExecutionWorkspace: ()=>resolveExecutionWorkspace,
-    buildUserContent: ()=>buildUserContent,
     detectStreamErrorMessage: ()=>detectStreamErrorMessage,
-    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    trackRootLangGraphRunId: ()=>trackRootLangGraphRunId,
     chunkHasAssistantText: ()=>chunkHasAssistantText,
     resolveModelRetryMiddlewareSettings: ()=>resolveModelRetryMiddlewareSettings,
-    AgentInvoker: ()=>AgentInvoker,
-    configureDeepAgentSummarizationMiddleware: ()=>configureDeepAgentSummarizationMiddleware,
     WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
     detectToolEventContext: ()=>detectToolEventContext,
     resolveExternalOutputMount: ()=>resolveExternalOutputMount,
-    resolveHumanInTheLoopSettings: ()=>resolveHumanInTheLoopSettings,
-    trackRootLangGraphRunId: ()=>trackRootLangGraphRunId,
-    isRootLangGraphTerminalEvent: ()=>isRootLangGraphTerminalEvent,
+    extractTokenUsageSnapshot: ()=>extractTokenUsageSnapshot,
     selectStreamingFallbackText: ()=>selectStreamingFallbackText,
     AGENTS_MEMORY_VIRTUAL_PATHS: ()=>AGENTS_MEMORY_VIRTUAL_PATHS,
+    estimateContextTokensFromChunk: ()=>estimateContextTokensFromChunk,
     resolveAgentExecutionWorkspace: ()=>resolveAgentExecutionWorkspace
 });
 const external_node_fs_namespaceObject = require("node:fs");
@@ -173,6 +181,13 @@ const configureDeepAgentSummarizationMiddleware = (agent, settings, model)=>{
         }
     });
 };
+const recompileDeepAgentWithMiddlewareOverrides = (agent)=>{
+    if (agent && "object" == typeof agent) {
+        const maybeWithConfig = agent.withConfig;
+        if ("function" == typeof maybeWithConfig) return maybeWithConfig.call(agent, {});
+    }
+    return agent;
+};
 const detectToolEventContext = (chunk)=>{
     if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return null;
     const eventChunk = chunk;
@@ -183,6 +198,85 @@ const detectToolEventContext = (chunk)=>{
         toolName
     };
 };
+const chunkHasBuiltInSummarizationSignal = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return false;
+    const eventChunk = chunk;
+    if ("on_chain_end" !== eventChunk.event || "SummarizationMiddleware.before_model" !== eventChunk.name) return false;
+    const data = eventChunk.data && "object" == typeof eventChunk.data && !Array.isArray(eventChunk.data) ? eventChunk.data : null;
+    const output = data?.output && "object" == typeof data.output && !Array.isArray(data.output) ? data.output : null;
+    const outputMessages = Array.isArray(output?.messages) ? output.messages : [];
+    return outputMessages.some((message)=>{
+        if (!message || "object" != typeof message || Array.isArray(message)) return false;
+        const messageRecord = message;
+        const additionalKwargs = messageRecord.additional_kwargs && "object" == typeof messageRecord.additional_kwargs && !Array.isArray(messageRecord.additional_kwargs) ? messageRecord.additional_kwargs : null;
+        return additionalKwargs?.lc_source === "summarization";
+    });
+};
+const SUMMARIZATION_MIDDLEWARE_NODE = "summarizationmiddleware.before_model";
+const normalizeNodeMarker = (value)=>{
+    if ("string" != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+};
+const extractSummarizationNodeCandidate = (value)=>{
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    const record = value;
+    const directCandidates = [
+        record.langgraph_node,
+        record.langgraphNode,
+        record.node,
+        record.node_id,
+        record.nodeId
+    ];
+    for (const candidate of directCandidates){
+        const normalized = normalizeNodeMarker(candidate);
+        if (normalized) return normalized;
+    }
+    const tagCandidates = [
+        record.tags,
+        record.ls_tags
+    ];
+    for (const tags of tagCandidates)if (Array.isArray(tags)) for (const tag of tags){
+        if ("string" != typeof tag) continue;
+        const normalizedTag = tag.trim().toLowerCase();
+        if (normalizedTag) {
+            if (normalizedTag === `langgraph_node:${SUMMARIZATION_MIDDLEWARE_NODE}`) return SUMMARIZATION_MIDDLEWARE_NODE;
+            if (normalizedTag === `langgraph_node=${SUMMARIZATION_MIDDLEWARE_NODE}`) return SUMMARIZATION_MIDDLEWARE_NODE;
+        }
+    }
+    return null;
+};
+const chunkBelongsToSummarizationMiddleware = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return false;
+    const eventChunk = chunk;
+    const nameNode = normalizeNodeMarker(eventChunk.name);
+    if (nameNode === SUMMARIZATION_MIDDLEWARE_NODE) return true;
+    const metadataCandidates = [
+        eventChunk.metadata,
+        eventChunk.data?.metadata,
+        eventChunk.data?.chunk,
+        eventChunk.data?.message
+    ];
+    for (const candidate of metadataCandidates){
+        const node = extractSummarizationNodeCandidate(candidate);
+        if (node === SUMMARIZATION_MIDDLEWARE_NODE) return true;
+    }
+    return false;
+};
+const SUMMARIZATION_ACTIVE_EVENTS = new Set([
+    "on_chat_model_start",
+    "on_chat_model_stream",
+    "on_chat_model_end",
+    "on_llm_start",
+    "on_llm_stream",
+    "on_llm_end"
+]);
+const chunkSignalsActiveSummarization = (chunk)=>{
+    if (!chunkBelongsToSummarizationMiddleware(chunk)) return false;
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return false;
+    const eventName = chunk.event;
+    return "string" == typeof eventName && SUMMARIZATION_ACTIVE_EVENTS.has(eventName);
+};
 const chunkHasAssistantText = (chunk)=>{
     if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return false;
     const eventChunk = chunk;
@@ -244,6 +338,202 @@ const detectStreamErrorMessage = (chunk)=>{
     if (null != errorPayload) return String(errorPayload);
     return eventName;
 };
+const getFiniteTokenNumber = (value)=>"number" == typeof value && Number.isFinite(value) ? value : 0;
+const asRecord = (value)=>value && "object" == typeof value && !Array.isArray(value) ? value : null;
+const collectTokenUsageSnapshot = (target, payload, visited, depth)=>{
+    if (depth > 8 || !payload || "object" != typeof payload) return;
+    if (visited.has(payload)) return;
+    visited.add(payload);
+    const record = payload;
+    const directInput = getFiniteTokenNumber(record.input_tokens) || getFiniteTokenNumber(record.inputTokens) || getFiniteTokenNumber(record.prompt_tokens) || getFiniteTokenNumber(record.promptTokens);
+    const directOutput = getFiniteTokenNumber(record.output_tokens) || getFiniteTokenNumber(record.outputTokens) || getFiniteTokenNumber(record.completion_tokens) || getFiniteTokenNumber(record.completionTokens);
+    const directTotal = getFiniteTokenNumber(record.total_tokens) || getFiniteTokenNumber(record.totalTokens);
+    if (directInput > 0) target.inputTokens = Math.max(target.inputTokens, directInput);
+    if (directOutput > 0) target.outputTokens = Math.max(target.outputTokens, directOutput);
+    if (directTotal > 0) target.totalTokens = Math.max(target.totalTokens, directTotal);
+    const nestedCandidates = [
+        record.usage,
+        record.usage_metadata,
+        record.usageMetadata,
+        record.tokenUsage,
+        record.response_metadata,
+        record.responseMetadata,
+        record.additional_kwargs,
+        record.additionalKwargs,
+        record.metadata,
+        record.data,
+        record.output,
+        record.message,
+        record.chunk
+    ];
+    for (const nested of nestedCandidates)collectTokenUsageSnapshot(target, nested, visited, depth + 1);
+};
+const extractTokenUsageSnapshot = (payload)=>{
+    const snapshot = {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+    };
+    const visited = new WeakSet();
+    collectTokenUsageSnapshot(snapshot, payload, visited, 0);
+    if (0 === snapshot.totalTokens) snapshot.totalTokens = snapshot.inputTokens + snapshot.outputTokens;
+    if (snapshot.inputTokens <= 0 && snapshot.outputTokens <= 0 && snapshot.totalTokens <= 0) return null;
+    return snapshot;
+};
+const getMessageClassName = (message)=>{
+    const id = message.id;
+    if (Array.isArray(id) && id.length > 0) {
+        const tail = id[id.length - 1];
+        if ("string" == typeof tail) return tail.trim().toLowerCase();
+    }
+    const type = "string" == typeof message.type ? message.type : "";
+    return type.trim().toLowerCase();
+};
+const getMessageRole = (message)=>{
+    const kwargs = asRecord(message.kwargs);
+    const additionalKwargs = asRecord(message.additional_kwargs);
+    const additionalKwargsCamel = asRecord(message.additionalKwargs);
+    const candidates = [
+        message.role,
+        kwargs?.role,
+        additionalKwargs?.role,
+        additionalKwargsCamel?.role
+    ];
+    for (const candidate of candidates)if ("string" == typeof candidate && candidate.trim()) return candidate.trim().toLowerCase();
+    return "";
+};
+const isMessageLikeRecord = (value)=>{
+    const record = asRecord(value);
+    if (!record) return false;
+    const role = getMessageRole(record);
+    if ("user" === role || "human" === role || "assistant" === role || "ai" === role || "system" === role || "tool" === role) return true;
+    const className = getMessageClassName(record);
+    if (className.includes("humanmessage") || className.includes("aimessage") || className.includes("toolmessage") || className.includes("systemmessage")) return true;
+    return "human" === className || "user" === className || "assistant" === className || "ai" === className || "system" === className || "tool" === className;
+};
+const extractTextFromContent = (content)=>{
+    if ("string" == typeof content) return content;
+    if (!Array.isArray(content)) return "";
+    return content.map((item)=>{
+        if ("string" == typeof item) return item;
+        const record = asRecord(item);
+        if (!record) return "";
+        if ("text" === record.type && "string" == typeof record.text) return record.text;
+        return "string" == typeof record.text ? record.text : "";
+    }).join("");
+};
+const extractMessageContent = (message)=>{
+    const kwargs = asRecord(message.kwargs);
+    const additionalKwargs = asRecord(message.additional_kwargs);
+    const additionalKwargsCamel = asRecord(message.additionalKwargs);
+    const candidates = [
+        message.content,
+        kwargs?.content,
+        additionalKwargs?.content,
+        additionalKwargsCamel?.content
+    ];
+    for (const candidate of candidates){
+        const extracted = extractTextFromContent(candidate);
+        if (extracted.length > 0) return extracted;
+    }
+    return "";
+};
+const extractToolCalls = (message)=>{
+    const kwargs = asRecord(message.kwargs);
+    const candidates = [
+        message.tool_calls,
+        message.toolCalls,
+        kwargs?.tool_calls,
+        kwargs?.toolCalls
+    ];
+    for (const candidate of candidates)if (Array.isArray(candidate) && candidate.length > 0) return candidate;
+    return [];
+};
+const extractToolCallId = (message)=>{
+    const kwargs = asRecord(message.kwargs);
+    const candidates = [
+        message.tool_call_id,
+        message.toolCallId,
+        kwargs?.tool_call_id,
+        kwargs?.toolCallId
+    ];
+    for (const candidate of candidates)if ("string" == typeof candidate && candidate.trim()) return candidate.trim();
+    return "";
+};
+const isAiMessageRecord = (message)=>{
+    const role = getMessageRole(message);
+    if ("assistant" === role || "ai" === role) return true;
+    const className = getMessageClassName(message);
+    return "ai" === className || "assistant" === className || className.includes("aimessage");
+};
+const isToolMessageRecord = (message)=>{
+    const role = getMessageRole(message);
+    if ("tool" === role) return true;
+    const className = getMessageClassName(message);
+    return "tool" === className || className.includes("toolmessage");
+};
+const estimateTokensForMessageArray = (messages)=>{
+    if (0 === messages.length) return 0;
+    let totalChars = 0;
+    for (const message of messages){
+        let textContent = extractMessageContent(message);
+        if (isAiMessageRecord(message)) {
+            const toolCalls = extractToolCalls(message);
+            if (toolCalls.length > 0) textContent += JSON.stringify(toolCalls);
+        }
+        if (isToolMessageRecord(message)) textContent += extractToolCallId(message);
+        totalChars += textContent.length;
+    }
+    return Math.ceil(totalChars / 4);
+};
+const collectMessageArraysFromPayload = (target, payload, visited, depth)=>{
+    if (depth > 7 || !payload || "object" != typeof payload) return;
+    if (visited.has(payload)) return;
+    visited.add(payload);
+    if (Array.isArray(payload)) {
+        const messageRecords = payload.filter(isMessageLikeRecord);
+        if (messageRecords.length > 0) target.push(messageRecords);
+        for (const item of payload)collectMessageArraysFromPayload(target, item, visited, depth + 1);
+        return;
+    }
+    const record = payload;
+    const directMessages = record.messages;
+    if (Array.isArray(directMessages)) {
+        const messageRecords = directMessages.filter(isMessageLikeRecord);
+        if (messageRecords.length > 0) target.push(messageRecords);
+    }
+    for (const nested of Object.values(record))if (nested && "object" == typeof nested) collectMessageArraysFromPayload(target, nested, visited, depth + 1);
+};
+const estimateContextTokensFromChunk = (chunk)=>{
+    const candidates = [];
+    collectMessageArraysFromPayload(candidates, chunk, new WeakSet(), 0);
+    if (0 === candidates.length) return null;
+    let estimate = 0;
+    for (const candidate of candidates){
+        const tokens = estimateTokensForMessageArray(candidate);
+        if (tokens > estimate) estimate = tokens;
+    }
+    return estimate > 0 ? estimate : null;
+};
+const detectContextSummarizationTransition = ({ thresholdTokens, peakInputTokens, currentInputTokens })=>{
+    if (!Number.isFinite(thresholdTokens) || !Number.isFinite(peakInputTokens) || !Number.isFinite(currentInputTokens)) return false;
+    if (thresholdTokens <= 0 || peakInputTokens <= 0 || currentInputTokens <= 0) return false;
+    if (peakInputTokens < 0.9 * thresholdTokens) return false;
+    if (currentInputTokens > 0.65 * thresholdTokens) return false;
+    if (currentInputTokens > 0.75 * peakInputTokens) return false;
+    return true;
+};
+const mergeTokenUsageSnapshots = (current, next)=>{
+    if (!next) return current;
+    if (!current) return next;
+    const merged = {
+        inputTokens: Math.max(current.inputTokens, next.inputTokens),
+        outputTokens: Math.max(current.outputTokens, next.outputTokens),
+        totalTokens: Math.max(current.totalTokens, next.totalTokens)
+    };
+    if (0 === merged.totalTokens) merged.totalTokens = merged.inputTokens + merged.outputTokens;
+    return merged;
+};
 const extractStreamEventRecord = (chunk)=>{
     if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return null;
     const record = chunk;
@@ -483,7 +773,7 @@ class AgentInvoker {
                 rootDir: outputMount.absolutePath,
                 virtualMode: true
             });
-            const standaloneAgent = (0, external_deepagents_namespaceObject.createDeepAgent)({
+            let standaloneAgent = (0, external_deepagents_namespaceObject.createDeepAgent)({
                 systemPrompt: targetAgent.systemPrompt,
                 tools: targetAgent.tools,
                 model: targetAgent.model,
@@ -499,10 +789,15 @@ class AgentInvoker {
                 checkpointer: checkpointer
             });
             configureDeepAgentSummarizationMiddleware(standaloneAgent, summarizationSettings, targetAgent.model);
+            standaloneAgent = recompileDeepAgentWithMiddlewareOverrides(standaloneAgent);
             this.logger.debug("Agent created, sending message");
             const userContent = buildUserContent(prompt, attachments, targetAgent.model);
             if (this.sessionManager && sessionId) {
                 this.logger.debug(`Using streaming with session: ${sessionId}`);
+                let streamTokenUsage = null;
+                let streamEstimatedContextTokens = 0;
+                let contextSummarizationStarted = false;
+                let contextSummarizationEmitted = false;
                 const stream = await standaloneAgent.streamEvents({
                     messages: [
                         {
@@ -535,7 +830,32 @@ class AgentInvoker {
                             cancelled: true
                         };
                     }
-                    this.outputManager.emitAgentStream(chunk);
+                    const chunkTokenUsage = extractTokenUsageSnapshot(chunk);
+                    streamTokenUsage = mergeTokenUsageSnapshots(streamTokenUsage, chunkTokenUsage);
+                    const isSummarizationChunk = chunkBelongsToSummarizationMiddleware(chunk);
+                    const isActiveSummarizationChunk = chunkSignalsActiveSummarization(chunk);
+                    if (isActiveSummarizationChunk && !contextSummarizationStarted) {
+                        contextSummarizationStarted = true;
+                        this.outputManager.emitContextSummarizing();
+                    }
+                    if (!isSummarizationChunk) {
+                        const chunkEstimatedContextTokens = estimateContextTokensFromChunk(chunk);
+                        if ("number" == typeof chunkEstimatedContextTokens && Number.isFinite(chunkEstimatedContextTokens) && chunkEstimatedContextTokens > streamEstimatedContextTokens) streamEstimatedContextTokens = chunkEstimatedContextTokens;
+                        this.outputManager.emitAgentStream(chunk, chunkTokenUsage || void 0, streamEstimatedContextTokens > 0 ? streamEstimatedContextTokens : void 0);
+                    }
+                    if (!contextSummarizationEmitted && summarizationSettings && chunkHasBuiltInSummarizationSignal(chunk)) {
+                        if (!contextSummarizationStarted) {
+                            contextSummarizationStarted = true;
+                            this.outputManager.emitContextSummarizing();
+                        }
+                        contextSummarizationEmitted = true;
+                        const observedInputTokens = chunkTokenUsage?.inputTokens || 0;
+                        this.outputManager.emitContextSummarized({
+                            inputTokens: observedInputTokens,
+                            peakInputTokens: observedInputTokens,
+                            thresholdTokens: summarizationSettings.maxTokensBeforeSummary
+                        });
+                    }
                     if (isRootLangGraphTerminalEvent(chunk, rootLangGraphRunId)) {
                         this.logger.debug("Detected root LangGraph on_chain_end event; finalizing stream without waiting for iterator shutdown");
                         break;
@@ -550,7 +870,10 @@ class AgentInvoker {
                     };
                 }
                 this.logger.info("Agent streaming completed successfully");
-                const completionPayload = {
+                const completionPayload = streamTokenUsage ? {
+                    streaming: true,
+                    tokenUsage: streamTokenUsage
+                } : {
                     streaming: true
                 };
                 emitCompletionAndContinuePostProcessing({
@@ -869,12 +1192,20 @@ exports.AgentInvoker = __webpack_exports__.AgentInvoker;
 exports.OUTPUT_VIRTUAL_PATH = __webpack_exports__.OUTPUT_VIRTUAL_PATH;
 exports.WORKDIR_VIRTUAL_PATH = __webpack_exports__.WORKDIR_VIRTUAL_PATH;
 exports.buildUserContent = __webpack_exports__.buildUserContent;
+exports.chunkBelongsToSummarizationMiddleware = __webpack_exports__.chunkBelongsToSummarizationMiddleware;
 exports.chunkHasAssistantText = __webpack_exports__.chunkHasAssistantText;
+exports.chunkHasBuiltInSummarizationSignal = __webpack_exports__.chunkHasBuiltInSummarizationSignal;
+exports.chunkSignalsActiveSummarization = __webpack_exports__.chunkSignalsActiveSummarization;
 exports.configureDeepAgentSummarizationMiddleware = __webpack_exports__.configureDeepAgentSummarizationMiddleware;
+exports.detectContextSummarizationTransition = __webpack_exports__.detectContextSummarizationTransition;
 exports.detectStreamErrorMessage = __webpack_exports__.detectStreamErrorMessage;
 exports.detectToolEventContext = __webpack_exports__.detectToolEventContext;
 exports.emitCompletionAndContinuePostProcessing = __webpack_exports__.emitCompletionAndContinuePostProcessing;
+exports.estimateContextTokensFromChunk = __webpack_exports__.estimateContextTokensFromChunk;
+exports.extractTokenUsageSnapshot = __webpack_exports__.extractTokenUsageSnapshot;
 exports.isRootLangGraphTerminalEvent = __webpack_exports__.isRootLangGraphTerminalEvent;
+exports.mergeTokenUsageSnapshots = __webpack_exports__.mergeTokenUsageSnapshots;
+exports.recompileDeepAgentWithMiddlewareOverrides = __webpack_exports__.recompileDeepAgentWithMiddlewareOverrides;
 exports.resolveAgentExecutionWorkspace = __webpack_exports__.resolveAgentExecutionWorkspace;
 exports.resolveAgentMemorySources = __webpack_exports__.resolveAgentMemorySources;
 exports.resolveExecutionWorkspace = __webpack_exports__.resolveExecutionWorkspace;
@@ -892,12 +1223,20 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "OUTPUT_VIRTUAL_PATH",
     "WORKDIR_VIRTUAL_PATH",
     "buildUserContent",
+    "chunkBelongsToSummarizationMiddleware",
     "chunkHasAssistantText",
+    "chunkHasBuiltInSummarizationSignal",
+    "chunkSignalsActiveSummarization",
     "configureDeepAgentSummarizationMiddleware",
+    "detectContextSummarizationTransition",
     "detectStreamErrorMessage",
     "detectToolEventContext",
     "emitCompletionAndContinuePostProcessing",
+    "estimateContextTokensFromChunk",
+    "extractTokenUsageSnapshot",
     "isRootLangGraphTerminalEvent",
+    "mergeTokenUsageSnapshots",
+    "recompileDeepAgentWithMiddlewareOverrides",
     "resolveAgentExecutionWorkspace",
     "resolveAgentMemorySources",
     "resolveExecutionWorkspace",

package/dist/cli/core/agentInvoker.d.ts

@@ -1,8 +1,8 @@
 import type { WingmanAgentConfig } from "@/agent/config/agentConfig.js";
 import { type MCPProxyConfig } from "@/agent/config/mcpClientManager.js";
 import { type ConnectedNodeTarget } from "@/agent/middleware/additional-messages.js";
-import { type TerminalSessionManager } from "@/agent/tools/terminal_session_manager.js";
 import type { NodeInvokeRequest, NodeInvokeResult } from "@/agent/tools/node_invoke.js";
+import { type TerminalSessionManager } from "@/agent/tools/terminal_session_manager.js";
 import type { WingmanAgent } from "@/types/agents.js";
 import type { Logger } from "../../logger.js";
 import type { WingmanConfigType } from "../config/schema.js";
@@ -114,6 +114,11 @@ export type HumanInTheLoopSettings = {
         argsSchema?: Record<string, any>;
     }>;
 };
+export type TokenUsageSnapshot = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+};
 export declare const resolveExecutionWorkspace: (workspace: string, workdir?: string | null) => string;
 export declare const resolveAgentExecutionWorkspace: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => string;
 export declare const resolveAgentMemorySources: (executionWorkspace: string) => string[];
@@ -124,11 +129,15 @@ export declare const resolveModelRetryMiddlewareSettings: (config: WingmanConfig
 export declare const resolveToolRetryMiddlewareSettings: (config: WingmanConfigType) => ToolRetryMiddlewareSettings | null;
 export declare const resolveHumanInTheLoopSettings: (config: WingmanConfigType) => HumanInTheLoopSettings | null;
 export declare const configureDeepAgentSummarizationMiddleware: (agent: any, settings: SummarizationMiddlewareSettings | null, model?: any) => void;
+export declare const recompileDeepAgentWithMiddlewareOverrides: <T>(agent: T) => T;
 type ToolEventContext = {
     event: "on_tool_start" | "on_tool_end" | "on_tool_error";
     toolName: string;
 };
 export declare const detectToolEventContext: (chunk: unknown) => ToolEventContext | null;
+export declare const chunkHasBuiltInSummarizationSignal: (chunk: unknown) => boolean;
+export declare const chunkBelongsToSummarizationMiddleware: (chunk: unknown) => boolean;
+export declare const chunkSignalsActiveSummarization: (chunk: unknown) => boolean;
 export declare const chunkHasAssistantText: (chunk: unknown) => boolean;
 export declare const selectStreamingFallbackText: (previousMessages: Array<{
     role?: unknown;
@@ -138,6 +147,14 @@ export declare const selectStreamingFallbackText: (previousMessages: Array<{
     content?: unknown;
 }>) => string | undefined;
 export declare const detectStreamErrorMessage: (chunk: unknown) => string | undefined;
+export declare const extractTokenUsageSnapshot: (payload: unknown) => TokenUsageSnapshot | null;
+export declare const estimateContextTokensFromChunk: (chunk: unknown) => number | null;
+export declare const detectContextSummarizationTransition: ({ thresholdTokens, peakInputTokens, currentInputTokens, }: {
+    thresholdTokens: number;
+    peakInputTokens: number;
+    currentInputTokens: number;
+}) => boolean;
+export declare const mergeTokenUsageSnapshots: (current: TokenUsageSnapshot | null, next: TokenUsageSnapshot | null) => TokenUsageSnapshot | null;
 export declare const trackRootLangGraphRunId: (currentRootLangGraphRunId: string | undefined, chunk: unknown) => string | undefined;
 export declare const isRootLangGraphTerminalEvent: (chunk: unknown, rootLangGraphRunId?: string) => boolean;
 export declare const emitCompletionAndContinuePostProcessing: (input: {