@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/cli/core/agentInvoker.cjs

@@ -24,26 +24,40 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    resolveExternalOutputMount: ()=>resolveExternalOutputMount,
-    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    resolveToolRetryMiddlewareSettings: ()=>resolveToolRetryMiddlewareSettings,
+    resolveSummarizationMiddlewareSettings: ()=>resolveSummarizationMiddlewareSettings,
     OUTPUT_VIRTUAL_PATH: ()=>OUTPUT_VIRTUAL_PATH,
-    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
-    AgentInvoker: ()=>AgentInvoker,
+    resolveExecutionWorkspace: ()=>resolveExecutionWorkspace,
     buildUserContent: ()=>buildUserContent,
-    resolveExecutionWorkspace: ()=>resolveExecutionWorkspace
+    detectStreamErrorMessage: ()=>detectStreamErrorMessage,
+    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    chunkHasAssistantText: ()=>chunkHasAssistantText,
+    resolveModelRetryMiddlewareSettings: ()=>resolveModelRetryMiddlewareSettings,
+    AgentInvoker: ()=>AgentInvoker,
+    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
+    configureDeepAgentSummarizationMiddleware: ()=>configureDeepAgentSummarizationMiddleware,
+    detectToolEventContext: ()=>detectToolEventContext,
+    resolveExternalOutputMount: ()=>resolveExternalOutputMount,
+    evaluateStreamingCompletion: ()=>evaluateStreamingCompletion,
+    resolveHumanInTheLoopSettings: ()=>resolveHumanInTheLoopSettings,
+    trackRootLangGraphRunId: ()=>trackRootLangGraphRunId,
+    isRootLangGraphTerminalEvent: ()=>isRootLangGraphTerminalEvent,
+    selectStreamingFallbackText: ()=>selectStreamingFallbackText
 });
-const external_deepagents_namespaceObject = require("deepagents");
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
+const external_deepagents_namespaceObject = require("deepagents");
+const external_langchain_namespaceObject = require("langchain");
 const external_uuid_namespaceObject = require("uuid");
-const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
-const loader_cjs_namespaceObject = require("../config/loader.cjs");
+const mcpClientManager_cjs_namespaceObject = require("../../agent/config/mcpClientManager.cjs");
 const additional_messages_cjs_namespaceObject = require("../../agent/middleware/additional-messages.cjs");
-const hooks_cjs_namespaceObject = require("../../agent/middleware/hooks.cjs");
 const merger_cjs_namespaceObject = require("../../agent/middleware/hooks/merger.cjs");
+const hooks_cjs_namespaceObject = require("../../agent/middleware/hooks.cjs");
 const media_compat_cjs_namespaceObject = require("../../agent/middleware/media-compat.cjs");
-const mcpClientManager_cjs_namespaceObject = require("../../agent/config/mcpClientManager.cjs");
+const terminal_session_manager_cjs_namespaceObject = require("../../agent/tools/terminal_session_manager.cjs");
 const uiRegistry_cjs_namespaceObject = require("../../agent/uiRegistry.cjs");
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const loader_cjs_namespaceObject = require("../config/loader.cjs");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -56,6 +70,7 @@ function _define_property(obj, key, value) {
 }
 const WORKDIR_VIRTUAL_PATH = "/workdir/";
 const OUTPUT_VIRTUAL_PATH = "/output/";
+const DEFAULT_DEEPAGENT_MODEL = "claude-sonnet-4-5-20250929";
 const isPathWithinRoot = (targetPath, rootPath)=>{
     const normalizedTarget = (0, external_node_path_namespaceObject.normalize)(targetPath);
     const normalizedRoot = (0, external_node_path_namespaceObject.normalize)(rootPath);
@@ -88,6 +103,206 @@ const resolveExternalOutputMount = (workspace, workdir, defaultOutputDir)=>{
         absolutePath: null
     };
 };
+const resolveSummarizationMiddlewareSettings = (config)=>{
+    if (!config.summarization?.enabled) return null;
+    return {
+        maxTokensBeforeSummary: config.summarization.maxTokensBeforeSummary,
+        messagesToKeep: config.summarization.messagesToKeep
+    };
+};
+const resolveModelRetryMiddlewareSettings = (config)=>{
+    if (!config.modelRetry?.enabled) return null;
+    return {
+        maxRetries: config.modelRetry.maxRetries,
+        backoffFactor: config.modelRetry.backoffFactor,
+        initialDelayMs: config.modelRetry.initialDelayMs,
+        maxDelayMs: config.modelRetry.maxDelayMs,
+        jitter: config.modelRetry.jitter,
+        onFailure: config.modelRetry.onFailure
+    };
+};
+const resolveToolRetryMiddlewareSettings = (config)=>{
+    if (!config.toolRetry?.enabled) return null;
+    return {
+        maxRetries: config.toolRetry.maxRetries,
+        backoffFactor: config.toolRetry.backoffFactor,
+        initialDelayMs: config.toolRetry.initialDelayMs,
+        maxDelayMs: config.toolRetry.maxDelayMs,
+        jitter: config.toolRetry.jitter,
+        onFailure: config.toolRetry.onFailure,
+        ...config.toolRetry.tools && config.toolRetry.tools.length > 0 ? {
+            tools: config.toolRetry.tools
+        } : {}
+    };
+};
+const resolveHumanInTheLoopSettings = (config)=>{
+    if (!config.humanInTheLoop?.enabled) return null;
+    const interruptOn = config.humanInTheLoop.interruptOn || {};
+    if (0 === Object.keys(interruptOn).length) return null;
+    return {
+        interruptOn
+    };
+};
+const configureDeepAgentSummarizationMiddleware = (agent, settings, model)=>{
+    const middleware = agent?.options?.middleware;
+    if (!Array.isArray(middleware)) return;
+    const index = middleware.findIndex((entry)=>entry?.name === "SummarizationMiddleware");
+    if (index < 0) return;
+    if (!settings) return void middleware.splice(index, 1);
+    middleware[index] = (0, external_langchain_namespaceObject.summarizationMiddleware)({
+        model: model || DEFAULT_DEEPAGENT_MODEL,
+        trigger: {
+            tokens: settings.maxTokensBeforeSummary
+        },
+        keep: {
+            messages: settings.messagesToKeep
+        }
+    });
+};
+const detectToolEventContext = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return null;
+    const eventChunk = chunk;
+    if ("on_tool_start" !== eventChunk.event && "on_tool_end" !== eventChunk.event && "on_tool_error" !== eventChunk.event) return null;
+    const toolName = "string" == typeof eventChunk.name && eventChunk.name.trim() ? eventChunk.name.trim() : "unknown";
+    return {
+        event: eventChunk.event,
+        toolName
+    };
+};
+const chunkHasAssistantText = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return false;
+    const eventChunk = chunk;
+    const eventName = "string" == typeof eventChunk.event ? eventChunk.event : void 0;
+    if ("on_chat_model_stream" === eventName) {
+        const data = eventChunk.data && "object" == typeof eventChunk.data ? eventChunk.data : null;
+        const messageChunk = data?.chunk || data?.message;
+        const content = messageChunk?.content;
+        if ("string" == typeof content) return content.length > 0;
+        if (Array.isArray(content)) return content.some((part)=>part && "object" == typeof part && "text" === part.type && "string" == typeof part.text && part.text.length > 0);
+    }
+    if ("on_llm_stream" === eventName) {
+        const data = eventChunk.data && "object" == typeof eventChunk.data ? eventChunk.data : null;
+        const llmChunk = data?.chunk && "object" == typeof data.chunk ? data.chunk : null;
+        return "string" == typeof llmChunk?.text && llmChunk.text.length > 0;
+    }
+    return false;
+};
+const selectStreamingFallbackText = (previousMessages, currentMessages)=>{
+    if (0 === currentMessages.length) return;
+    const previousAssistantCounts = new Map();
+    for (const message of previousMessages){
+        if (!message || "object" != typeof message) continue;
+        if ("assistant" !== message.role) continue;
+        if ("string" != typeof message.content) continue;
+        const content = message.content.trim();
+        if (content) previousAssistantCounts.set(content, (previousAssistantCounts.get(content) || 0) + 1);
+    }
+    let fallback;
+    for (const message of currentMessages){
+        if (!message || "object" != typeof message) continue;
+        if ("assistant" !== message.role) continue;
+        if ("string" != typeof message.content) continue;
+        const content = message.content.trim();
+        if (!content) continue;
+        const remaining = previousAssistantCounts.get(content) || 0;
+        if (remaining > 0) {
+            previousAssistantCounts.set(content, remaining - 1);
+            continue;
+        }
+        fallback = content;
+    }
+    return fallback;
+};
+const detectStreamErrorMessage = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return;
+    const eventChunk = chunk;
+    const eventName = "string" == typeof eventChunk.event ? eventChunk.event : void 0;
+    if (!eventName || !eventName.endsWith("_error")) return;
+    if ("on_tool_error" === eventName) return;
+    const data = eventChunk.data && "object" == typeof eventChunk.data ? eventChunk.data : null;
+    const errorPayload = data?.error || eventChunk.error || data?.output || data?.chunk;
+    if ("string" == typeof errorPayload && errorPayload.trim()) return errorPayload.trim();
+    if (errorPayload && "object" == typeof errorPayload) {
+        const record = errorPayload;
+        if ("string" == typeof record.message && record.message.trim()) return record.message.trim();
+        if ("string" == typeof record.error && record.error.trim()) return record.error.trim();
+    }
+    if (null != errorPayload) return String(errorPayload);
+    return eventName;
+};
+const extractStreamEventRecord = (chunk)=>{
+    if (!chunk || "object" != typeof chunk || Array.isArray(chunk)) return null;
+    const record = chunk;
+    return "string" == typeof record.event ? record : null;
+};
+const normalizeEventName = (value)=>{
+    if ("string" != typeof value) return;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized.toLowerCase() : void 0;
+};
+const normalizeEventParentRunIds = (value)=>{
+    if (Array.isArray(value)) return value.filter((item)=>"string" == typeof item).map((item)=>item.trim()).filter(Boolean);
+    if ("string" == typeof value && value.trim()) return [
+        value.trim()
+    ];
+    return [];
+};
+const extractEventParentRunIds = (eventRecord)=>{
+    const parentCandidates = [
+        eventRecord.parent_ids,
+        eventRecord.parentIds,
+        eventRecord.metadata?.parent_ids,
+        eventRecord.metadata?.parentIds,
+        eventRecord.data?.parent_ids,
+        eventRecord.data?.parentIds
+    ];
+    for (const candidate of parentCandidates){
+        const parentIds = normalizeEventParentRunIds(candidate);
+        if (parentIds.length > 0) return parentIds;
+    }
+    return [];
+};
+const extractEventRunId = (eventRecord)=>{
+    const runCandidates = [
+        eventRecord.run_id,
+        eventRecord.runId,
+        eventRecord.data?.run_id,
+        eventRecord.data?.runId
+    ];
+    for (const candidate of runCandidates)if ("string" == typeof candidate && candidate.trim()) return candidate.trim();
+};
+const isRootLangGraphChainEvent = (eventRecord, eventType)=>{
+    if (eventRecord.event !== eventType) return false;
+    const eventName = normalizeEventName(eventRecord.name);
+    if ("langgraph" !== eventName) return false;
+    return 0 === extractEventParentRunIds(eventRecord).length;
+};
+const trackRootLangGraphRunId = (currentRootLangGraphRunId, chunk)=>{
+    if (currentRootLangGraphRunId) return currentRootLangGraphRunId;
+    const eventRecord = extractStreamEventRecord(chunk);
+    if (!eventRecord || !isRootLangGraphChainEvent(eventRecord, "on_chain_start")) return currentRootLangGraphRunId;
+    return extractEventRunId(eventRecord) || currentRootLangGraphRunId;
+};
+const isRootLangGraphTerminalEvent = (chunk, rootLangGraphRunId)=>{
+    if (!rootLangGraphRunId) return false;
+    const eventRecord = extractStreamEventRecord(chunk);
+    if (!eventRecord || !isRootLangGraphChainEvent(eventRecord, "on_chain_end")) return false;
+    const chunkRunId = extractEventRunId(eventRecord);
+    return Boolean(chunkRunId && chunkRunId === rootLangGraphRunId);
+};
+const evaluateStreamingCompletion = (input)=>{
+    if (!input.sawAssistantText && !input.fallbackText) {
+        const message = input.streamErrorMessage ? `Model call failed: ${input.streamErrorMessage}` : "Model completed without a response. Check provider logs for request errors.";
+        return {
+            status: "blocked",
+            reason: input.streamErrorMessage ? "stream_error" : "empty_stream_response",
+            message
+        };
+    }
+    return {
+        status: "ok"
+    };
+};
 class AgentInvoker {
     findAllAgents() {
         const agentConfigs = this.loader.loadAllAgentConfigs();
@@ -98,11 +313,21 @@ class AgentInvoker {
     }
     async invokeAgent(agentName, prompt, sessionId, attachments, options) {
         let cancellationHandled = false;
+        let activeToolName = null;
+        let lastToolName = null;
+        let sawAssistantText = false;
+        let streamErrorMessage;
+        let rootLangGraphRunId;
+        let preInvocationMessages = null;
         const isCancelled = ()=>options?.signal?.aborted === true;
         try {
+            const hookSessionId = sessionId || (0, external_uuid_namespaceObject.v4)();
             const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
-            const loader = (0, external_node_path_namespaceObject.normalize)(executionWorkspace) === (0, external_node_path_namespaceObject.normalize)(this.workspace) ? this.loader : new agentLoader_cjs_namespaceObject.AgentLoader(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace);
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace, {
+                terminalOwnerId: `${agentName}:${hookSessionId}`,
+                terminalSessionManager: this.terminalSessionManager
+            });
             const targetAgent = await loader.loadAgent(agentName);
             if (!targetAgent) throw new Error(`Agent "${agentName}" not found`);
             this.logger.info(`Invoking agent: ${agentName}`);
@@ -111,7 +336,6 @@ class AgentInvoker {
             this.logger.debug(`Found ${this.wingmanConfig.toolHooks ? "global hooks" : "no global hooks"}`);
             this.logger.debug(`Found ${targetAgent.toolHooks ? "agent-specific hooks" : "no agent-specific hooks"}`);
             const mergedHooks = (0, merger_cjs_namespaceObject.mergeHooks)(this.wingmanConfig.toolHooks, targetAgent.toolHooks);
-            const hookSessionId = sessionId || (0, external_uuid_namespaceObject.v4)();
             const mcpConfigs = [];
             if (targetAgent.mcpConfig) mcpConfigs.push(targetAgent.mcpConfig);
             if (targetAgent.mcpUseGlobal && this.wingmanConfig.mcp) mcpConfigs.push(this.wingmanConfig.mcp);
@@ -147,6 +371,29 @@ class AgentInvoker {
                     skillsDirectory
                 })
             ];
+            const summarizationSettings = resolveSummarizationMiddlewareSettings(this.wingmanConfig);
+            const modelRetrySettings = resolveModelRetryMiddlewareSettings(this.wingmanConfig);
+            if (modelRetrySettings) middleware.push((0, external_langchain_namespaceObject.modelRetryMiddleware)({
+                maxRetries: modelRetrySettings.maxRetries,
+                backoffFactor: modelRetrySettings.backoffFactor,
+                initialDelayMs: modelRetrySettings.initialDelayMs,
+                maxDelayMs: modelRetrySettings.maxDelayMs,
+                jitter: modelRetrySettings.jitter,
+                onFailure: modelRetrySettings.onFailure
+            }));
+            const toolRetrySettings = resolveToolRetryMiddlewareSettings(this.wingmanConfig);
+            if (toolRetrySettings) middleware.push((0, external_langchain_namespaceObject.toolRetryMiddleware)({
+                maxRetries: toolRetrySettings.maxRetries,
+                backoffFactor: toolRetrySettings.backoffFactor,
+                initialDelayMs: toolRetrySettings.initialDelayMs,
+                maxDelayMs: toolRetrySettings.maxDelayMs,
+                jitter: toolRetrySettings.jitter,
+                onFailure: toolRetrySettings.onFailure,
+                ...toolRetrySettings.tools ? {
+                    tools: toolRetrySettings.tools
+                } : {}
+            }));
+            const hitlSettings = resolveHumanInTheLoopSettings(this.wingmanConfig);
             if (mergedHooks) {
                 this.logger.debug(`Adding hooks middleware with ${mergedHooks.PreToolUse?.length || 0} PreToolUse hooks, ${mergedHooks.PostToolUse?.length || 0} PostToolUse hooks, and ${mergedHooks.Stop?.length || 0} Stop hooks`);
                 middleware.push((0, hooks_cjs_namespaceObject.createHooksMiddleware)(mergedHooks, executionWorkspace, hookSessionId, this.logger));
@@ -193,14 +440,25 @@ class AgentInvoker {
                         virtualMode: true
                     }), backendOverrides),
                 middleware: middleware,
+                interruptOn: hitlSettings?.interruptOn,
                 skills: skillsSources,
                 subagents: targetAgent.subagents || [],
                 checkpointer: checkpointer
             });
+            configureDeepAgentSummarizationMiddleware(standaloneAgent, summarizationSettings, targetAgent.model);
             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}`);
+                try {
+                    const messages = await this.sessionManager.listMessages(sessionId);
+                    preInvocationMessages = messages.map((message)=>({
+                            role: message.role,
+                            content: message.content
+                        }));
+                } catch (stateError) {
+                    this.logger.debug("Failed to capture pre-invocation session state", stateError);
+                }
                 const stream = await standaloneAgent.streamEvents({
                     messages: [
                         {
@@ -217,6 +475,15 @@ class AgentInvoker {
                     signal: options?.signal
                 });
                 for await (const chunk of stream){
+                    rootLangGraphRunId = trackRootLangGraphRunId(rootLangGraphRunId, chunk);
+                    if (!sawAssistantText && chunkHasAssistantText(chunk)) sawAssistantText = true;
+                    if (!streamErrorMessage) streamErrorMessage = detectStreamErrorMessage(chunk);
+                    const toolEvent = detectToolEventContext(chunk);
+                    if (toolEvent) {
+                        lastToolName = toolEvent.toolName;
+                        if ("on_tool_start" === toolEvent.event) activeToolName = toolEvent.toolName;
+                        else if (activeToolName === toolEvent.toolName) activeToolName = null;
+                    }
                     if (isCancelled()) {
                         cancellationHandled = true;
                         this.logger.info("Agent invocation cancelled");
@@ -227,6 +494,10 @@ class AgentInvoker {
                         };
                     }
                     this.outputManager.emitAgentStream(chunk);
+                    if (isRootLangGraphTerminalEvent(chunk, rootLangGraphRunId)) {
+                        this.logger.debug("Detected root LangGraph on_chain_end event; finalizing stream without waiting for iterator shutdown");
+                        break;
+                    }
                 }
                 if (isCancelled()) {
                     cancellationHandled = true;
@@ -236,9 +507,37 @@ class AgentInvoker {
                         cancelled: true
                     };
                 }
-                this.logger.info("Agent streaming completed successfully");
+                let fallbackText;
+                if (!sawAssistantText && this.sessionManager && sessionId && preInvocationMessages) try {
+                    const sessionMessages = await this.sessionManager.listMessages(sessionId);
+                    fallbackText = selectStreamingFallbackText(preInvocationMessages, sessionMessages.map((message)=>({
+                            role: message.role,
+                            content: message.content
+                        })));
+                } catch (stateError) {
+                    this.logger.debug("Failed to derive streaming fallback text from session state", stateError);
+                }
+                const completionOutcome = evaluateStreamingCompletion({
+                    sawAssistantText,
+                    fallbackText,
+                    streamErrorMessage
+                });
+                if ("blocked" === completionOutcome.status) {
+                    this.logger.warn(completionOutcome.message);
+                    this.outputManager.emitAgentError(completionOutcome.message);
+                    return {
+                        blocked: true,
+                        reason: completionOutcome.reason
+                    };
+                }
+                this.logger.info("Agent streaming completed successfully", {
+                    usedFallbackText: Boolean(fallbackText)
+                });
                 this.outputManager.emitAgentComplete({
-                    streaming: true
+                    streaming: true,
+                    ...fallbackText ? {
+                        fallbackText
+                    } : {}
                 });
                 return {
                     streaming: true
@@ -286,8 +585,10 @@ class AgentInvoker {
                     cancelled: true
                 };
             }
-            this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
-            this.outputManager.emitAgentError(error);
+            this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}${activeToolName ? ` (while running tool "${activeToolName}")` : lastToolName ? ` (last tool: "${lastToolName}")` : ""}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorWithToolContext = activeToolName ? `${errorMessage} (while running tool "${activeToolName}")` : lastToolName ? `${errorMessage} (last tool: "${lastToolName}")` : errorMessage;
+            this.outputManager.emitAgentError(errorWithToolContext);
             throw error;
         } finally{
             if (this.mcpManager) {
@@ -313,6 +614,7 @@ class AgentInvoker {
         _define_property(this, "wingmanConfig", void 0);
         _define_property(this, "mcpManager", null);
         _define_property(this, "sessionManager", null);
+        _define_property(this, "terminalSessionManager", void 0);
         _define_property(this, "workdir", null);
         _define_property(this, "defaultOutputDir", null);
         this.outputManager = options.outputManager;
@@ -320,6 +622,7 @@ class AgentInvoker {
         this.workspace = options.workspace || process.cwd();
         this.configDir = options.configDir || ".wingman";
         this.sessionManager = options.sessionManager || null;
+        this.terminalSessionManager = options.terminalSessionManager || (0, terminal_session_manager_cjs_namespaceObject.getSharedTerminalSessionManager)();
         this.workdir = options.workdir || null;
         this.defaultOutputDir = options.defaultOutputDir || null;
         const configLoader = new loader_cjs_namespaceObject.WingmanConfigLoader(this.configDir, this.workspace);
@@ -516,17 +819,41 @@ 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.chunkHasAssistantText = __webpack_exports__.chunkHasAssistantText;
+exports.configureDeepAgentSummarizationMiddleware = __webpack_exports__.configureDeepAgentSummarizationMiddleware;
+exports.detectStreamErrorMessage = __webpack_exports__.detectStreamErrorMessage;
+exports.detectToolEventContext = __webpack_exports__.detectToolEventContext;
+exports.evaluateStreamingCompletion = __webpack_exports__.evaluateStreamingCompletion;
+exports.isRootLangGraphTerminalEvent = __webpack_exports__.isRootLangGraphTerminalEvent;
 exports.resolveExecutionWorkspace = __webpack_exports__.resolveExecutionWorkspace;
 exports.resolveExternalOutputMount = __webpack_exports__.resolveExternalOutputMount;
+exports.resolveHumanInTheLoopSettings = __webpack_exports__.resolveHumanInTheLoopSettings;
+exports.resolveModelRetryMiddlewareSettings = __webpack_exports__.resolveModelRetryMiddlewareSettings;
+exports.resolveSummarizationMiddlewareSettings = __webpack_exports__.resolveSummarizationMiddlewareSettings;
+exports.resolveToolRetryMiddlewareSettings = __webpack_exports__.resolveToolRetryMiddlewareSettings;
+exports.selectStreamingFallbackText = __webpack_exports__.selectStreamingFallbackText;
 exports.toWorkspaceAliasVirtualPath = __webpack_exports__.toWorkspaceAliasVirtualPath;
+exports.trackRootLangGraphRunId = __webpack_exports__.trackRootLangGraphRunId;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AgentInvoker",
     "OUTPUT_VIRTUAL_PATH",
     "WORKDIR_VIRTUAL_PATH",
     "buildUserContent",
+    "chunkHasAssistantText",
+    "configureDeepAgentSummarizationMiddleware",
+    "detectStreamErrorMessage",
+    "detectToolEventContext",
+    "evaluateStreamingCompletion",
+    "isRootLangGraphTerminalEvent",
     "resolveExecutionWorkspace",
     "resolveExternalOutputMount",
-    "toWorkspaceAliasVirtualPath"
+    "resolveHumanInTheLoopSettings",
+    "resolveModelRetryMiddlewareSettings",
+    "resolveSummarizationMiddlewareSettings",
+    "resolveToolRetryMiddlewareSettings",
+    "selectStreamingFallbackText",
+    "toWorkspaceAliasVirtualPath",
+    "trackRootLangGraphRunId"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -1,14 +1,17 @@
-import type { OutputManager } from "./outputManager.js";
-import type { Logger } from "../../logger.js";
 import type { WingmanAgentConfig } from "@/agent/config/agentConfig.js";
+import { type TerminalSessionManager } from "@/agent/tools/terminal_session_manager.js";
 import type { WingmanAgent } from "@/types/agents.js";
-import { SessionManager } from "./sessionManager.js";
+import type { Logger } from "../../logger.js";
+import type { WingmanConfigType } from "../config/schema.js";
+import type { OutputManager } from "./outputManager.js";
+import type { SessionManager } from "./sessionManager.js";
 export interface AgentInvokerOptions {
     workspace?: string;
     configDir?: string;
     outputManager: OutputManager;
     logger: Logger;
     sessionManager?: SessionManager;
+    terminalSessionManager?: TerminalSessionManager;
     workdir?: string | null;
     defaultOutputDir?: string | null;
 }
@@ -79,9 +82,65 @@ export type ExternalOutputMount = {
     virtualPath: string | null;
     absolutePath: string | null;
 };
+export type SummarizationMiddlewareSettings = {
+    maxTokensBeforeSummary: number;
+    messagesToKeep: number;
+};
+export type ModelRetryMiddlewareSettings = {
+    maxRetries: number;
+    backoffFactor: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    jitter: boolean;
+    onFailure: "continue" | "error";
+};
+export type ToolRetryMiddlewareSettings = ModelRetryMiddlewareSettings & {
+    tools?: string[];
+};
+export type HumanInTheLoopSettings = {
+    interruptOn: Record<string, boolean | {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+        description?: string;
+        argsSchema?: Record<string, any>;
+    }>;
+};
 export declare const resolveExecutionWorkspace: (workspace: string, workdir?: string | null) => string;
 export declare const toWorkspaceAliasVirtualPath: (absolutePath: string) => string | null;
 export declare const resolveExternalOutputMount: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => ExternalOutputMount;
+export declare const resolveSummarizationMiddlewareSettings: (config: WingmanConfigType) => SummarizationMiddlewareSettings | null;
+export declare const resolveModelRetryMiddlewareSettings: (config: WingmanConfigType) => ModelRetryMiddlewareSettings | null;
+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;
+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 chunkHasAssistantText: (chunk: unknown) => boolean;
+export declare const selectStreamingFallbackText: (previousMessages: Array<{
+    role?: unknown;
+    content?: unknown;
+}>, currentMessages: Array<{
+    role?: unknown;
+    content?: unknown;
+}>) => string | undefined;
+export declare const detectStreamErrorMessage: (chunk: unknown) => string | undefined;
+export declare const trackRootLangGraphRunId: (currentRootLangGraphRunId: string | undefined, chunk: unknown) => string | undefined;
+export declare const isRootLangGraphTerminalEvent: (chunk: unknown, rootLangGraphRunId?: string) => boolean;
+type StreamingCompletionOutcome = {
+    status: "blocked";
+    reason: "stream_error" | "empty_stream_response";
+    message: string;
+} | {
+    status: "ok";
+};
+type EvaluateStreamingCompletionInput = {
+    sawAssistantText: boolean;
+    fallbackText?: string;
+    streamErrorMessage?: string;
+};
+export declare const evaluateStreamingCompletion: (input: EvaluateStreamingCompletionInput) => StreamingCompletionOutcome;
 export declare class AgentInvoker {
     private loader;
     private outputManager;
@@ -91,6 +150,7 @@ export declare class AgentInvoker {
     private wingmanConfig;
     private mcpManager;
     private sessionManager;
+    private terminalSessionManager;
     private workdir;
     private defaultOutputDir;
     constructor(options: AgentInvokerOptions);