@wingman-ai/gateway 0.5.0 → 0.5.2

package/dist/cli/core/agentInvoker.js

@@ -124,6 +124,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;
@@ -134,6 +141,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;
@@ -195,6 +281,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;
@@ -434,7 +716,7 @@ class AgentInvoker {
                 rootDir: outputMount.absolutePath,
                 virtualMode: true
             });
-            const standaloneAgent = createDeepAgent({
+            let standaloneAgent = createDeepAgent({
                 systemPrompt: targetAgent.systemPrompt,
                 tools: targetAgent.tools,
                 model: targetAgent.model,
@@ -450,10 +732,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: [
                         {
@@ -486,7 +773,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;
@@ -501,7 +813,10 @@ class AgentInvoker {
                     };
                 }
                 this.logger.info("Agent streaming completed successfully");
-                const completionPayload = {
+                const completionPayload = streamTokenUsage ? {
+                    streaming: true,
+                    tokenUsage: streamTokenUsage
+                } : {
                     streaming: true
                 };
                 emitCompletionAndContinuePostProcessing({
@@ -815,4 +1130,4 @@ function buildAttachmentPreview(attachments) {
     if (hasImage) return "[image]";
     return "";
 }
-export { AGENTS_MEMORY_VIRTUAL_PATHS, AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, emitCompletionAndContinuePostProcessing, isRootLangGraphTerminalEvent, resolveAgentExecutionWorkspace, resolveAgentMemorySources, resolveExecutionWorkspace, resolveExternalOutputMount, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, toWorkspaceAliasVirtualPath, trackRootLangGraphRunId };
+export { AGENTS_MEMORY_VIRTUAL_PATHS, AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, chunkBelongsToSummarizationMiddleware, chunkHasAssistantText, chunkHasBuiltInSummarizationSignal, chunkSignalsActiveSummarization, configureDeepAgentSummarizationMiddleware, detectContextSummarizationTransition, detectStreamErrorMessage, detectToolEventContext, emitCompletionAndContinuePostProcessing, estimateContextTokensFromChunk, extractTokenUsageSnapshot, isRootLangGraphTerminalEvent, mergeTokenUsageSnapshots, recompileDeepAgentWithMiddlewareOverrides, resolveAgentExecutionWorkspace, resolveAgentMemorySources, resolveExecutionWorkspace, resolveExternalOutputMount, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, toWorkspaceAliasVirtualPath, trackRootLangGraphRunId };

package/dist/cli/core/outputManager.cjs

@@ -66,10 +66,31 @@ class OutputManager extends external_node_events_namespaceObject.EventEmitter {
             timestamp: new Date().toISOString()
         });
     }
-    emitAgentStream(chunk) {
+    emitAgentStream(chunk, tokenUsage, estimatedContextTokens) {
         this.emitEvent({
             type: "agent-stream",
             chunk,
+            ...tokenUsage ? {
+                tokenUsage
+            } : {},
+            ..."number" == typeof estimatedContextTokens && Number.isFinite(estimatedContextTokens) && estimatedContextTokens > 0 ? {
+                estimatedContextTokens: Math.round(estimatedContextTokens)
+            } : {},
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitContextSummarizing() {
+        this.emitEvent({
+            type: "context-summarizing",
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitContextSummarized(payload) {
+        this.emitEvent({
+            type: "context-summarized",
+            inputTokens: payload.inputTokens,
+            peakInputTokens: payload.peakInputTokens,
+            thresholdTokens: payload.thresholdTokens,
             timestamp: new Date().toISOString()
         });
     }

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

@@ -31,7 +31,23 @@ export declare class OutputManager extends EventEmitter {
      * Emit agent stream chunk
      * Forwards raw chunks from deepagents/LangGraph for client-side interpretation
      */
-    emitAgentStream(chunk: any): void;
+    emitAgentStream(chunk: any, tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, estimatedContextTokens?: number): void;
+    /**
+     * Emit explicit context summarization start signal
+     */
+    emitContextSummarizing(): void;
+    /**
+     * Emit explicit context summarization signal
+     */
+    emitContextSummarized(payload: {
+        inputTokens: number;
+        peakInputTokens: number;
+        thresholdTokens: number;
+    }): void;
     /**
      * Emit agent completion
      */

package/dist/cli/core/outputManager.js

@@ -38,10 +38,31 @@ class OutputManager extends EventEmitter {
             timestamp: new Date().toISOString()
         });
     }
-    emitAgentStream(chunk) {
+    emitAgentStream(chunk, tokenUsage, estimatedContextTokens) {
         this.emitEvent({
             type: "agent-stream",
             chunk,
+            ...tokenUsage ? {
+                tokenUsage
+            } : {},
+            ..."number" == typeof estimatedContextTokens && Number.isFinite(estimatedContextTokens) && estimatedContextTokens > 0 ? {
+                estimatedContextTokens: Math.round(estimatedContextTokens)
+            } : {},
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitContextSummarizing() {
+        this.emitEvent({
+            type: "context-summarizing",
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitContextSummarized(payload) {
+        this.emitEvent({
+            type: "context-summarized",
+            inputTokens: payload.inputTokens,
+            peakInputTokens: payload.peakInputTokens,
+            thresholdTokens: payload.thresholdTokens,
             timestamp: new Date().toISOString()
         });
     }

package/dist/cli/types.d.ts

@@ -130,6 +130,23 @@ export interface AgentStartEvent {
 export interface AgentStreamEvent {
     type: "agent-stream";
     chunk: any;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    estimatedContextTokens?: number;
+    timestamp: string;
+}
+export interface AgentContextSummarizingEvent {
+    type: "context-summarizing";
+    timestamp: string;
+}
+export interface AgentContextSummarizedEvent {
+    type: "context-summarized";
+    inputTokens: number;
+    peakInputTokens: number;
+    thresholdTokens: number;
     timestamp: string;
 }
 export interface AgentCompleteEvent {
@@ -178,7 +195,7 @@ export interface SkillRemoveEvent {
     skill: string;
     timestamp: string;
 }
-export type OutputEvent = LogEvent | AgentStartEvent | AgentStreamEvent | AgentCompleteEvent | AgentErrorEvent | SkillBrowseEvent | SkillInstallProgressEvent | SkillInstallCompleteEvent | SkillListEvent | SkillRemoveEvent;
+export type OutputEvent = LogEvent | AgentStartEvent | AgentStreamEvent | AgentContextSummarizingEvent | AgentContextSummarizedEvent | AgentCompleteEvent | AgentErrorEvent | SkillBrowseEvent | SkillInstallProgressEvent | SkillInstallCompleteEvent | SkillListEvent | SkillRemoveEvent;
 export interface TextBlock {
     content: string;
     isStreaming: boolean;

package/dist/cli/ui/App.cjs

@@ -203,6 +203,8 @@ const App = ({ outputManager })=>{
                             break;
                     }
                     break;
+                case "context-summarized":
+                    break;
                 case "agent-complete":
                     setIsStreaming(false);
                     setIsComplete(true);

package/dist/cli/ui/App.js

@@ -165,6 +165,8 @@ const App = ({ outputManager })=>{
                             break;
                     }
                     break;
+                case "context-summarized":
+                    break;
                 case "agent-complete":
                     setIsStreaming(false);
                     setIsComplete(true);

package/dist/gateway/server.cjs

@@ -1652,6 +1652,7 @@ class GatewayServer {
                     defaultAgentId,
                     outputRoot: this.resolveOutputRoot(),
                     dynamicUiEnabled: this.wingmanConfig.gateway?.dynamicUiEnabled !== false,
+                    summarization: this.wingmanConfig.summarization,
                     voice: this.wingmanConfig.voice,
                     agents
                 }, null, 2), {

package/dist/gateway/server.js

@@ -1617,6 +1617,7 @@ class GatewayServer {
                     defaultAgentId,
                     outputRoot: this.resolveOutputRoot(),
                     dynamicUiEnabled: this.wingmanConfig.gateway?.dynamicUiEnabled !== false,
+                    summarization: this.wingmanConfig.summarization,
                     voice: this.wingmanConfig.voice,
                     agents
                 }, null, 2), {