@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/cli/core/agentInvoker.js

@@ -1,15 +1,17 @@
-import { CompositeBackend, FilesystemBackend, createDeepAgent } from "deepagents";
 import { existsSync } from "node:fs";
 import { isAbsolute, join, normalize, sep } from "node:path";
+import { CompositeBackend, FilesystemBackend, createDeepAgent } from "deepagents";
+import { modelRetryMiddleware, summarizationMiddleware, toolRetryMiddleware } from "langchain";
 import { v4 } from "uuid";
-import { AgentLoader } from "../../agent/config/agentLoader.js";
-import { WingmanConfigLoader } from "../config/loader.js";
+import { MCPClientManager } from "../../agent/config/mcpClientManager.js";
 import { additionalMessageMiddleware } from "../../agent/middleware/additional-messages.js";
-import { createHooksMiddleware } from "../../agent/middleware/hooks.js";
 import { mergeHooks } from "../../agent/middleware/hooks/merger.js";
+import { createHooksMiddleware } from "../../agent/middleware/hooks.js";
 import { mediaCompatibilityMiddleware } from "../../agent/middleware/media-compat.js";
-import { MCPClientManager } from "../../agent/config/mcpClientManager.js";
+import { getSharedTerminalSessionManager } from "../../agent/tools/terminal_session_manager.js";
 import { getBundledSkillsPath } from "../../agent/uiRegistry.js";
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { WingmanConfigLoader } from "../config/loader.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -22,6 +24,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 = normalize(targetPath);
     const normalizedRoot = normalize(rootPath);
@@ -54,6 +57,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] = 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();
@@ -64,11 +267,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 || v4();
             const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
-            const loader = normalize(executionWorkspace) === normalize(this.workspace) ? this.loader : new AgentLoader(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace);
+            const loader = new 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}`);
@@ -77,7 +290,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 = mergeHooks(this.wingmanConfig.toolHooks, targetAgent.toolHooks);
-            const hookSessionId = sessionId || v4();
             const mcpConfigs = [];
             if (targetAgent.mcpConfig) mcpConfigs.push(targetAgent.mcpConfig);
             if (targetAgent.mcpUseGlobal && this.wingmanConfig.mcp) mcpConfigs.push(this.wingmanConfig.mcp);
@@ -113,6 +325,29 @@ class AgentInvoker {
                     skillsDirectory
                 })
             ];
+            const summarizationSettings = resolveSummarizationMiddlewareSettings(this.wingmanConfig);
+            const modelRetrySettings = resolveModelRetryMiddlewareSettings(this.wingmanConfig);
+            if (modelRetrySettings) middleware.push(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(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(createHooksMiddleware(mergedHooks, executionWorkspace, hookSessionId, this.logger));
@@ -159,14 +394,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: [
                         {
@@ -183,6 +429,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");
@@ -193,6 +448,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;
@@ -202,9 +461,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
@@ -252,8 +539,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) {
@@ -279,6 +568,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;
@@ -286,6 +576,7 @@ class AgentInvoker {
         this.workspace = options.workspace || process.cwd();
         this.configDir = options.configDir || ".wingman";
         this.sessionManager = options.sessionManager || null;
+        this.terminalSessionManager = options.terminalSessionManager || getSharedTerminalSessionManager();
         this.workdir = options.workdir || null;
         this.defaultOutputDir = options.defaultOutputDir || null;
         const configLoader = new WingmanConfigLoader(this.configDir, this.workspace);
@@ -478,4 +769,4 @@ function buildAttachmentPreview(attachments) {
     if (hasImage) return "[image]";
     return "";
 }
-export { AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, resolveExecutionWorkspace, resolveExternalOutputMount, toWorkspaceAliasVirtualPath };
+export { AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, evaluateStreamingCompletion, isRootLangGraphTerminalEvent, resolveExecutionWorkspace, resolveExternalOutputMount, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, toWorkspaceAliasVirtualPath, trackRootLangGraphRunId };

package/dist/cli/core/sessionManager.cjs

@@ -68,6 +68,8 @@ class SessionManager {
 
       CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
       CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status_updated ON sessions(status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status_agent_updated ON sessions(status, agent_name, updated_at DESC);
     `);
     }
     createSession(agentName, name) {
@@ -407,13 +409,38 @@ function extractContentBlocks(entry) {
 }
 function extractMessageContent(entry, blocks = []) {
     if (!entry || "object" != typeof entry) return "";
-    if ("string" == typeof entry.content) return entry.content;
-    if ("string" == typeof entry?.kwargs?.content) return entry.kwargs.content;
-    if ("string" == typeof entry?.additional_kwargs?.content) return entry.additional_kwargs.content;
-    if ("string" == typeof entry?.data?.content) return entry.data.content;
-    if (blocks.length > 0) return blocks.filter((block)=>block && "text" === block.type && block.text).map((block)=>block.text).join("");
+    const candidates = [
+        entry.content,
+        entry?.kwargs?.content,
+        entry?.additional_kwargs?.content,
+        entry?.data?.content
+    ];
+    for (const candidate of candidates){
+        const extracted = extractTextContent(candidate);
+        if (extracted) return extracted;
+    }
+    if (blocks.length > 0) return extractTextContent(blocks);
+    return "";
+}
+function extractTextContent(value, depth = 0) {
+    if (depth > 5 || null == value) return "";
+    if ("string" == typeof value) return value;
+    if (Array.isArray(value)) return value.map((entry)=>extractTextContent(entry, depth + 1)).filter((entry)=>entry.length > 0).join("");
+    if ("object" != typeof value) return "";
+    const record = value;
+    if ("string" == typeof record.text) return record.text;
+    if (record.text && "object" == typeof record.text && "string" == typeof record.text.value) return record.text.value;
+    if ("string" == typeof record.output_text) return record.output_text;
+    if ("string" == typeof record.input_text) return record.input_text;
+    if ("string" == typeof record.value && isTextLikeContentType(record.type)) return record.value;
+    if ("content" in record) return extractTextContent(record.content, depth + 1);
     return "";
 }
+function isTextLikeContentType(type) {
+    if ("string" != typeof type) return false;
+    const normalized = type.toLowerCase();
+    return "text" === normalized || "input_text" === normalized || "output_text" === normalized || "text_delta" === normalized;
+}
 function isToolMessage(entry) {
     if (!entry || "object" != typeof entry) return false;
     const role = entry.role || entry?.kwargs?.role || entry?.additional_kwargs?.role;

package/dist/cli/core/sessionManager.js

@@ -35,6 +35,8 @@ class SessionManager {
 
       CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
       CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status_updated ON sessions(status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status_agent_updated ON sessions(status, agent_name, updated_at DESC);
     `);
     }
     createSession(agentName, name) {
@@ -374,13 +376,38 @@ function extractContentBlocks(entry) {
 }
 function extractMessageContent(entry, blocks = []) {
     if (!entry || "object" != typeof entry) return "";
-    if ("string" == typeof entry.content) return entry.content;
-    if ("string" == typeof entry?.kwargs?.content) return entry.kwargs.content;
-    if ("string" == typeof entry?.additional_kwargs?.content) return entry.additional_kwargs.content;
-    if ("string" == typeof entry?.data?.content) return entry.data.content;
-    if (blocks.length > 0) return blocks.filter((block)=>block && "text" === block.type && block.text).map((block)=>block.text).join("");
+    const candidates = [
+        entry.content,
+        entry?.kwargs?.content,
+        entry?.additional_kwargs?.content,
+        entry?.data?.content
+    ];
+    for (const candidate of candidates){
+        const extracted = extractTextContent(candidate);
+        if (extracted) return extracted;
+    }
+    if (blocks.length > 0) return extractTextContent(blocks);
+    return "";
+}
+function extractTextContent(value, depth = 0) {
+    if (depth > 5 || null == value) return "";
+    if ("string" == typeof value) return value;
+    if (Array.isArray(value)) return value.map((entry)=>extractTextContent(entry, depth + 1)).filter((entry)=>entry.length > 0).join("");
+    if ("object" != typeof value) return "";
+    const record = value;
+    if ("string" == typeof record.text) return record.text;
+    if (record.text && "object" == typeof record.text && "string" == typeof record.text.value) return record.text.value;
+    if ("string" == typeof record.output_text) return record.output_text;
+    if ("string" == typeof record.input_text) return record.input_text;
+    if ("string" == typeof record.value && isTextLikeContentType(record.type)) return record.value;
+    if ("content" in record) return extractTextContent(record.content, depth + 1);
     return "";
 }
+function isTextLikeContentType(type) {
+    if ("string" != typeof type) return false;
+    const normalized = type.toLowerCase();
+    return "text" === normalized || "input_text" === normalized || "output_text" === normalized || "text_delta" === normalized;
+}
 function isToolMessage(entry) {
     if (!entry || "object" != typeof entry) return false;
     const role = entry.role || entry?.kwargs?.role || entry?.additional_kwargs?.role;

package/dist/cli/core/streamParser.cjs

@@ -151,6 +151,21 @@ function parseStreamEventChunk(chunk) {
             timestamp: Date.now()
         };
     }
+    if ("on_tool_error" === chunk.event) {
+        const toolId = "string" == typeof chunk.run_id ? chunk.run_id : void 0;
+        if (!toolId) return null;
+        const errorPayload = chunk.data?.error ?? chunk.error;
+        const error = "string" == typeof errorPayload ? errorPayload : "string" == typeof errorPayload?.message ? errorPayload.message : errorPayload ? String(errorPayload) : "Tool error";
+        return {
+            toolResult: {
+                id: toolId,
+                output: chunk.data?.output ?? "",
+                error
+            },
+            type: "tool-result",
+            timestamp: Date.now()
+        };
+    }
     return null;
 }
 function normalizeMessagesFromChunk(chunk) {

package/dist/cli/core/streamParser.js

@@ -121,6 +121,21 @@ function parseStreamEventChunk(chunk) {
             timestamp: Date.now()
         };
     }
+    if ("on_tool_error" === chunk.event) {
+        const toolId = "string" == typeof chunk.run_id ? chunk.run_id : void 0;
+        if (!toolId) return null;
+        const errorPayload = chunk.data?.error ?? chunk.error;
+        const error = "string" == typeof errorPayload ? errorPayload : "string" == typeof errorPayload?.message ? errorPayload.message : errorPayload ? String(errorPayload) : "Tool error";
+        return {
+            toolResult: {
+                id: toolId,
+                output: chunk.data?.output ?? "",
+                error
+            },
+            type: "tool-result",
+            timestamp: Date.now()
+        };
+    }
     return null;
 }
 function normalizeMessagesFromChunk(chunk) {

package/dist/cli/index.cjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 "use strict";
 var __webpack_exports__ = {};
-const external_logger_cjs_namespaceObject = require("../logger.cjs");
-const loader_cjs_namespaceObject = require("./config/loader.cjs");
 const env_cjs_namespaceObject = require("../gateway/env.cjs");
-const outputManager_cjs_namespaceObject = require("./core/outputManager.cjs");
+const external_logger_cjs_namespaceObject = require("../logger.cjs");
 const agent_cjs_namespaceObject = require("./commands/agent.cjs");
-const skill_cjs_namespaceObject = require("./commands/skill.cjs");
 const gateway_cjs_namespaceObject = require("./commands/gateway.cjs");
-const provider_cjs_namespaceObject = require("./commands/provider.cjs");
 const init_cjs_namespaceObject = require("./commands/init.cjs");
+const provider_cjs_namespaceObject = require("./commands/provider.cjs");
+const skill_cjs_namespaceObject = require("./commands/skill.cjs");
+const loader_cjs_namespaceObject = require("./config/loader.cjs");
+const outputManager_cjs_namespaceObject = require("./core/outputManager.cjs");
 function parseArgs(argv) {
     const args = argv.slice(2);
     if (args.includes("--help") || args.includes("-h")) return {
@@ -114,6 +114,7 @@ Examples:
   wingman skill install pdf
   wingman skill list
   wingman provider status
+  wingman provider login codex
   wingman provider login copilot --token="<token>"
   wingman gateway start
   wingman gateway join ws://localhost:3000/ws --name="agent-1"

package/dist/cli/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { createLogger, getLogFilePath } from "../logger.js";
-import { WingmanConfigLoader } from "./config/loader.js";
 import { getGatewayTokenFromEnv } from "../gateway/env.js";
-import { OutputManager } from "./core/outputManager.js";
+import { createLogger, getLogFilePath } from "../logger.js";
 import { executeAgentCommand } from "./commands/agent.js";
-import { executeSkillCommand } from "./commands/skill.js";
 import { executeGatewayCommand } from "./commands/gateway.js";
-import { executeProviderCommand } from "./commands/provider.js";
 import { executeInitCommand } from "./commands/init.js";
+import { executeProviderCommand } from "./commands/provider.js";
+import { executeSkillCommand } from "./commands/skill.js";
+import { WingmanConfigLoader } from "./config/loader.js";
+import { OutputManager } from "./core/outputManager.js";
 function parseArgs(argv) {
     const args = argv.slice(2);
     if (args.includes("--help") || args.includes("-h")) return {
@@ -112,6 +112,7 @@ Examples:
   wingman skill install pdf
   wingman skill list
   wingman provider status
+  wingman provider login codex
   wingman provider login copilot --token="<token>"
   wingman gateway start
   wingman gateway join ws://localhost:3000/ws --name="agent-1"