@wingman-ai/gateway 0.2.1 → 0.2.3

package/dist/cli/config/schema.d.ts

@@ -14,6 +14,52 @@ export declare const SkillsConfigSchema: z.ZodObject<{
     skillsDirectory: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export declare const SummarizationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type SummarizationConfig = z.infer<typeof SummarizationConfigSchema>;
+export declare const ModelRetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        continue: "continue";
+    }>>>;
+}, z.core.$strip>;
+export type ModelRetryConfig = z.infer<typeof ModelRetryConfigSchema>;
+export declare const ToolRetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        continue: "continue";
+    }>>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ToolRetryConfig = z.infer<typeof ToolRetryConfigSchema>;
+export declare const HumanInTheLoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    interruptOn: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        allowedDecisions: z.ZodArray<z.ZodEnum<{
+            approve: "approve";
+            edit: "edit";
+            reject: "reject";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>;
+export type HumanInTheLoopConfig = z.infer<typeof HumanInTheLoopConfigSchema>;
 export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
     host: z.ZodDefault<z.ZodString>;
     port: z.ZodDefault<z.ZodNumber>;
@@ -92,6 +138,48 @@ export declare const WingmanConfigSchema: z.ZodObject<{
     }>>>;
     defaultAgent: z.ZodOptional<z.ZodString>;
     recursionLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    summarization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    modelRetry: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            continue: "continue";
+        }>>>;
+    }, z.core.$strip>>>;
+    toolRetry: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            continue: "continue";
+        }>>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    humanInTheLoop: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        interruptOn: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            allowedDecisions: z.ZodArray<z.ZodEnum<{
+                approve: "approve";
+                edit: "edit";
+                reject: "reject";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>]>>>>;
+    }, z.core.$strip>>>;
     toolHooks: z.ZodOptional<z.ZodObject<{
         PreToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
             matcher: z.ZodOptional<z.ZodString>;

package/dist/cli/config/schema.js

@@ -16,6 +16,45 @@ const SkillsConfigSchema = z.object({
     githubToken: z.string().optional().describe("GitHub personal access token for higher API rate limits"),
     skillsDirectory: z.string().default("skills").describe("Directory to install skills in")
 });
+const SummarizationConfigSchema = z.object({
+    enabled: z.boolean().optional().default(true).describe("Enable conversation history summarization"),
+    maxTokensBeforeSummary: z.number().min(1000).max(1000000).optional().default(12000).describe("Token threshold before summarizing conversation history"),
+    messagesToKeep: z.number().min(2).max(100).optional().default(8).describe("How many most recent messages to keep after summarization")
+});
+const RetryOnFailureSchema = z["enum"]([
+    "continue",
+    "error"
+]);
+const BaseRetryConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false).describe("Enable retry middleware"),
+    maxRetries: z.number().min(0).max(20).optional().default(2).describe("Maximum number of retry attempts"),
+    backoffFactor: z.number().min(0).max(10).optional().default(2).describe("Exponential backoff multiplier"),
+    initialDelayMs: z.number().min(0).max(120000).optional().default(1000).describe("Initial delay before first retry in milliseconds"),
+    maxDelayMs: z.number().min(0).max(300000).optional().default(60000).describe("Maximum backoff delay in milliseconds"),
+    jitter: z.boolean().optional().default(true).describe("Add randomized jitter to retry delays"),
+    onFailure: RetryOnFailureSchema.optional().default("continue").describe("Behavior when retries are exhausted")
+});
+const ModelRetryConfigSchema = BaseRetryConfigSchema;
+const ToolRetryConfigSchema = BaseRetryConfigSchema.extend({
+    tools: z.array(z.string().min(1)).optional().describe("Optional list of tool names to apply retry logic to")
+});
+const AllowedDecisionSchema = z["enum"]([
+    "approve",
+    "edit",
+    "reject"
+]);
+const InterruptOnToolConfigSchema = z.union([
+    z.boolean(),
+    z.object({
+        allowedDecisions: z.array(AllowedDecisionSchema).min(1).describe("Allowed decisions for this tool"),
+        description: z.string().optional().describe("Optional custom review prompt for this tool"),
+        argsSchema: z.record(z.string(), z.any()).optional().describe("Optional argument schema for edit decisions")
+    })
+]);
+const HumanInTheLoopConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false).describe("Enable human-in-the-loop tool approval"),
+    interruptOn: z.record(z.string(), InterruptOnToolConfigSchema).optional().default({}).describe("Per-tool approval policy mapping")
+});
 const GatewayAuthSchema = z.object({
     mode: z["enum"]([
         "token",
@@ -144,6 +183,33 @@ const WingmanConfigSchema = z.object({
     ]).optional().default("info"),
     defaultAgent: z.string().optional(),
     recursionLimit: z.number().min(1).max(1000000).optional().default(5000),
+    summarization: SummarizationConfigSchema.optional().default({
+        enabled: true,
+        maxTokensBeforeSummary: 12000,
+        messagesToKeep: 8
+    }),
+    modelRetry: ModelRetryConfigSchema.optional().default({
+        enabled: true,
+        maxRetries: 2,
+        backoffFactor: 2,
+        initialDelayMs: 1000,
+        maxDelayMs: 60000,
+        jitter: true,
+        onFailure: "continue"
+    }),
+    toolRetry: ToolRetryConfigSchema.optional().default({
+        enabled: false,
+        maxRetries: 2,
+        backoffFactor: 2,
+        initialDelayMs: 1000,
+        maxDelayMs: 60000,
+        jitter: true,
+        onFailure: "continue"
+    }),
+    humanInTheLoop: HumanInTheLoopConfigSchema.optional().default({
+        enabled: false,
+        interruptOn: {}
+    }),
     toolHooks: HooksConfigSchema.optional().describe("Global tool hooks configuration"),
     hooks: InternalHooksConfigSchema.optional().describe("Internal hook configuration"),
     search: SearchConfigSchema.optional().default({
@@ -213,4 +279,4 @@ function validateConfig(data) {
         };
     }
 }
-export { AgentsConfigSchema, GatewayConfigSchema, SearchConfigSchema, SkillsConfigSchema, WingmanConfigSchema, validateConfig };
+export { AgentsConfigSchema, GatewayConfigSchema, HumanInTheLoopConfigSchema, ModelRetryConfigSchema, SearchConfigSchema, SkillsConfigSchema, SummarizationConfigSchema, ToolRetryConfigSchema, WingmanConfigSchema, validateConfig };

package/dist/cli/core/agentInvoker.cjs

@@ -24,26 +24,35 @@ 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
+    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    chunkHasAssistantText: ()=>chunkHasAssistantText,
+    resolveModelRetryMiddlewareSettings: ()=>resolveModelRetryMiddlewareSettings,
+    AgentInvoker: ()=>AgentInvoker,
+    detectToolEventContext: ()=>detectToolEventContext,
+    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
+    configureDeepAgentSummarizationMiddleware: ()=>configureDeepAgentSummarizationMiddleware,
+    resolveExternalOutputMount: ()=>resolveExternalOutputMount,
+    resolveHumanInTheLoopSettings: ()=>resolveHumanInTheLoopSettings,
+    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 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 +65,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 +98,101 @@ 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) 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 = (sessionMessages, invocationStartedAt, windowMs = 1000)=>{
+    for(let i = sessionMessages.length - 1; i >= 0; i -= 1){
+        const message = sessionMessages[i];
+        if (!message || "object" != typeof message) continue;
+        if ("assistant" === message.role) {
+            if ("number" == typeof message.createdAt && !(message.createdAt < invocationStartedAt - windowMs)) {
+                if ("string" == typeof message.content && message.content.trim()) return message.content;
+            }
+        }
+    }
+};
 class AgentInvoker {
     findAllAgents() {
         const agentConfigs = this.loader.loadAllAgentConfigs();
@@ -96,7 +201,13 @@ class AgentInvoker {
     async findAgent(name) {
         return await this.loader.loadAgent(name);
     }
-    async invokeAgent(agentName, prompt, sessionId, attachments) {
+    async invokeAgent(agentName, prompt, sessionId, attachments, options) {
+        const invocationStartedAt = Date.now();
+        let cancellationHandled = false;
+        let activeToolName = null;
+        let lastToolName = null;
+        let sawAssistantText = false;
+        const isCancelled = ()=>options?.signal?.aborted === true;
         try {
             const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
@@ -145,6 +256,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));
@@ -191,10 +325,12 @@ 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) {
@@ -211,12 +347,58 @@ class AgentInvoker {
                     configurable: {
                         thread_id: sessionId
                     },
-                    version: "v2"
+                    version: "v2",
+                    signal: options?.signal
                 });
-                for await (const chunk of stream)this.outputManager.emitAgentStream(chunk);
+                for await (const chunk of stream){
+                    if (!sawAssistantText && chunkHasAssistantText(chunk)) sawAssistantText = true;
+                    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");
+                        this.outputManager.emitAgentError("Request cancelled");
+                        if ("function" == typeof stream?.return) await stream.return();
+                        return {
+                            cancelled: true
+                        };
+                    }
+                    this.outputManager.emitAgentStream(chunk);
+                }
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent streaming completed successfully");
+                let fallbackText;
+                if (!sawAssistantText && this.sessionManager && sessionId) try {
+                    const sessionMessages = await this.sessionManager.listMessages(sessionId);
+                    fallbackText = selectStreamingFallbackText(sessionMessages, invocationStartedAt);
+                } catch (stateError) {
+                    this.logger.debug("Failed to derive streaming fallback text from session state", stateError);
+                }
+                if (!sawAssistantText && !fallbackText) {
+                    const emptyResponseMessage = "Model completed without a response. Check provider logs for request errors.";
+                    this.logger.warn(emptyResponseMessage);
+                    this.outputManager.emitAgentError(emptyResponseMessage);
+                    return {
+                        blocked: true,
+                        reason: "empty_stream_response"
+                    };
+                }
                 this.outputManager.emitAgentComplete({
-                    streaming: true
+                    streaming: true,
+                    ...fallbackText ? {
+                        fallbackText
+                    } : {}
                 });
                 return {
                     streaming: true
@@ -224,6 +406,14 @@ class AgentInvoker {
             }
             {
                 this.logger.debug("Using blocking invoke (no session manager)");
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 const result = await standaloneAgent.invoke({
                     messages: [
                         {
@@ -232,15 +422,34 @@ class AgentInvoker {
                         }
                     ]
                 }, {
-                    recursionLimit: this.wingmanConfig.recursionLimit
+                    recursionLimit: this.wingmanConfig.recursionLimit,
+                    signal: options?.signal
                 });
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent completed successfully");
                 this.outputManager.emitAgentComplete(result);
                 return result;
             }
         } catch (error) {
-            this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
-            this.outputManager.emitAgentError(error);
+            const abortError = isCancelled() || error instanceof Error && ("AbortError" === error.name || "CancelledError" === error.name || /abort|cancel/i.test(error.message));
+            if (abortError) {
+                if (!cancellationHandled) this.outputManager.emitAgentError("Request cancelled");
+                this.logger.info("Agent invocation cancelled");
+                return {
+                    cancelled: true
+                };
+            }
+            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) {
@@ -469,16 +678,32 @@ 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.detectToolEventContext = __webpack_exports__.detectToolEventContext;
 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;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AgentInvoker",
     "OUTPUT_VIRTUAL_PATH",
     "WORKDIR_VIRTUAL_PATH",
     "buildUserContent",
+    "chunkHasAssistantText",
+    "configureDeepAgentSummarizationMiddleware",
+    "detectToolEventContext",
     "resolveExecutionWorkspace",
     "resolveExternalOutputMount",
+    "resolveHumanInTheLoopSettings",
+    "resolveModelRetryMiddlewareSettings",
+    "resolveSummarizationMiddlewareSettings",
+    "resolveToolRetryMiddlewareSettings",
+    "selectStreamingFallbackText",
     "toWorkspaceAliasVirtualPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -1,8 +1,9 @@
-import type { OutputManager } from "./outputManager.js";
-import type { Logger } from "../../logger.js";
 import type { WingmanAgentConfig } from "@/agent/config/agentConfig.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;
@@ -12,6 +13,9 @@ export interface AgentInvokerOptions {
     workdir?: string | null;
     defaultOutputDir?: string | null;
 }
+export interface InvokeAgentOptions {
+    signal?: AbortSignal;
+}
 export type ImageAttachment = {
     kind?: "image";
     dataUrl: string;
@@ -76,9 +80,47 @@ 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";
+    toolName: string;
+};
+export declare const detectToolEventContext: (chunk: unknown) => ToolEventContext | null;
+export declare const chunkHasAssistantText: (chunk: unknown) => boolean;
+export declare const selectStreamingFallbackText: (sessionMessages: Array<{
+    role?: unknown;
+    createdAt?: unknown;
+    content?: unknown;
+}>, invocationStartedAt: number, windowMs?: number) => string | undefined;
 export declare class AgentInvoker {
     private loader;
     private outputManager;
@@ -99,7 +141,7 @@ export declare class AgentInvoker {
     /**
      * Invoke a specific agent directly (bypassing main orchestration)
      */
-    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[]): Promise<any>;
+    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[], options?: InvokeAgentOptions): Promise<any>;
     /**
      * List all available agents with their descriptions
      */