@genesislcap/ai-assistant 14.421.1 → 14.422.0

package/dist/esm/components/chat-driver/chat-driver.js

@@ -1,11 +1,13 @@
 import { __awaiter } from "tslib";
 import { MalformedFunctionCallError } from '@genesislcap/foundation-ai';
+import { applyHistoryCap } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
 const DEFAULT_MAX_TOOL_ITERATIONS = 50;
 const DEFAULT_MAX_FOLD_OPERATIONS = 5;
 const DEFAULT_MAX_UNKNOWN_TOOL_CALLS = 5;
 const MAX_MALFORMED_RETRIES = 2;
+const MAX_EMPTY_RESPONSE_RETRIES = 3;
 const SUGGESTIONS_HISTORY_WINDOW = 8;
 /** Name reserved for the cross-agent handoff tool — injected by OrchestratingDriver. */
 export const REQUEST_CONTINUATION_TOOL = 'request_continuation';
@@ -35,6 +37,8 @@ export class ChatDriver extends EventTarget {
         this.consecutiveFoldOps = 0;
         /** Consecutive unknown-tool calls without a real tool call. Reset on real tool execution. */
         this.consecutiveUnknownToolCalls = 0;
+        /** Sub-agents declared on the active agent config, keyed by name. */
+        this.subAgentsMap = new Map();
         this.toolHandlers = toolHandlers;
         this.toolDefinitions = toolDefinitions;
         this.systemPrompt = systemPrompt;
@@ -46,16 +50,24 @@ export class ChatDriver extends EventTarget {
      * each specialist turn so the shared driver runs with the right tools and prompt.
      */
     applyAgent(config) {
-        var _a, _b;
+        var _a, _b, _c;
         this.systemPrompt = config.systemPrompt;
         this.toolDefinitions = (_a = config.toolDefinitions) !== null && _a !== void 0 ? _a : [];
         this.toolHandlers = (_b = config.toolHandlers) !== null && _b !== void 0 ? _b : {};
         this.primerHistory = config.primerHistory;
         this.activeAgentName = config.name;
+        this.subAgentsMap = new Map(((_c = config.subAgents) !== null && _c !== void 0 ? _c : []).map((s) => [s.name, s]));
         // Reset fold state when agent changes — each specialist starts fresh
         this.foldStack = [];
         this.consecutiveFoldOps = 0;
     }
+    /**
+     * Returns the early-stop result set by `completeSubAgent`, if any.
+     * Called by a parent `ChatDriver` after running this instance as a sub-agent.
+     */
+    getSubAgentCompletion() {
+        return this.subAgentCompletion;
+    }
     /**
      * Optional transform applied to conversation history immediately before each LLM request.
      * Cleared when `undefined`. Does not alter stored history.
@@ -212,6 +224,7 @@ export class ChatDriver extends EventTarget {
                 return { reason: 'done' };
             }
             this.busy = true;
+            this.subAgentCompletion = undefined;
             this.appendToHistory({ role: 'user', content: userInput, attachments });
             try {
                 return yield this.runToolLoop(userInput, attachments);
@@ -226,6 +239,89 @@ export class ChatDriver extends EventTarget {
             }
         });
     }
+    /**
+     * Builds the context object passed to every tool handler call.
+     * Centralised here so fold shortcut dispatch and the main tool loop use the
+     * same context without duplication.
+     *
+     * @param traceCapture - Optional per-invocation slot. When provided, the trace
+     *   from any sub-agent call is written here rather than to shared instance state,
+     *   so parallel tool calls each capture their own trace independently.
+     */
+    buildHandlerContext(traceCapture) {
+        return Object.assign(Object.assign({ requestInteraction: (componentName, data) => this.requestInteraction(componentName, data) }, (this.subAgentsMap.size > 0 && {
+            requestSubAgent: (name, options) => this.invokeSubAgent(name, options).then(({ result, trace }) => {
+                if (traceCapture)
+                    traceCapture.trace = trace;
+                return result;
+            }),
+        })), { completeSubAgent: (result) => {
+                var _a;
+                if (this.subAgentCompletion) {
+                    logger.warn(`ChatDriver(${(_a = this.activeAgentName) !== null && _a !== void 0 ? _a : 'unknown'}): completeSubAgent called more than once — ignoring`);
+                    return;
+                }
+                this.subAgentCompletion = { result };
+            } });
+    }
+    /**
+     * Creates a child `ChatDriver` for the named sub-agent, runs it to completion,
+     * and returns its structured result (or final text fallback) together with the
+     * full child conversation trace. Callers receive both values so each parallel
+     * invocation can capture its own trace without touching shared instance state.
+     */
+    invokeSubAgent(name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const subConfig = this.subAgentsMap.get(name);
+            if (!subConfig) {
+                const available = [...this.subAgentsMap.keys()].join(', ') || '(none)';
+                throw new Error(`Sub-agent "${name}" not found on agent "${this.activeAgentName}". Available: ${available}`);
+            }
+            const { task, historyCap, context } = options !== null && options !== void 0 ? options : {};
+            // Exclude the current in-flight assistant message (the one with tool calls that
+            // triggered this invocation) — it has unresolved tool calls that would confuse
+            // the sub-agent into thinking it needs to handle tools it doesn't own.
+            const lastMsg = this.history[this.history.length - 1];
+            const baseHistory = (lastMsg === null || lastMsg === void 0 ? void 0 : lastMsg.role) === 'assistant' && ((_a = lastMsg.toolCalls) === null || _a === void 0 ? void 0 : _a.length)
+                ? this.history.slice(0, -1)
+                : this.history;
+            const snapshotHistory = historyCap != null ? applyHistoryCap(baseHistory, historyCap) : [...baseHistory];
+            const contextMessages = context
+                ? [{ role: 'user', content: `[Sub-agent context]: ${JSON.stringify(context)}` }]
+                : [];
+            const effectivePrimer = [
+                ...snapshotHistory,
+                ...contextMessages,
+                ...((_b = subConfig.primerHistory) !== null && _b !== void 0 ? _b : []),
+            ];
+            const child = new ChatDriver(this.aiProvider);
+            child.applyAgent(Object.assign(Object.assign({}, subConfig), { primerHistory: effectivePrimer }));
+            const forwardTrace = (e) => {
+                this.dispatchEvent(new CustomEvent('sub-agent-history-updated', {
+                    detail: { agentName: subConfig.name, history: e.detail },
+                }));
+            };
+            child.addEventListener('history-updated', forwardTrace);
+            this.dispatchEvent(new CustomEvent('sub-agent-start', { detail: { name } }));
+            try {
+                yield child.sendMessage(task !== null && task !== void 0 ? task : '');
+            }
+            finally {
+                child.removeEventListener('history-updated', forwardTrace);
+                this.dispatchEvent(new CustomEvent('sub-agent-stop', { detail: { name } }));
+            }
+            const trace = child.getHistory();
+            const completion = child.getSubAgentCompletion();
+            if (completion) {
+                return { result: completion.result, trace };
+            }
+            const finalMsg = [...trace]
+                .reverse()
+                .find((m) => { var _a, _b; return m.role === 'assistant' && !((_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.length) && ((_b = m.content) === null || _b === void 0 ? void 0 : _b.trim()); });
+            return { result: ((_c = finalMsg === null || finalMsg === void 0 ? void 0 : finalMsg.content) !== null && _c !== void 0 ? _c : ''), trace };
+        });
+    }
     /**
      * Continue the tool loop from current history without appending a new user message.
      * Used by OrchestratingDriver after an agent handoff.
@@ -239,6 +335,7 @@ export class ChatDriver extends EventTarget {
                 return { reason: 'done' };
             }
             this.busy = true;
+            this.subAgentCompletion = undefined;
             try {
                 return yield this.runToolLoop('', undefined, transientPrimer);
             }
@@ -327,9 +424,7 @@ export class ChatDriver extends EventTarget {
                 const innerArgs = typeof args[key] === 'object' && args[key] !== null
                     ? args[key]
                     : {};
-                return innerHandler(innerArgs, {
-                    requestInteraction: (c, d) => this.requestInteraction(c, d),
-                }).then((r) => (typeof r === 'string' ? r : JSON.stringify(r)));
+                return innerHandler(innerArgs, this.buildHandlerContext()).then((r) => typeof r === 'string' ? r : JSON.stringify(r));
             }
         }
         // Normal two-step open
@@ -395,7 +490,12 @@ export class ChatDriver extends EventTarget {
             let currentAttachments = attachments;
             let iterations = 0;
             let malformedAttempts = 0;
-            const startIteration = currentInput ? 1 : 0;
+            let emptyResponseAttempts = 0;
+            // True only for the very first LLM call. Used to exclude the pending user message
+            // from history (it is passed separately as currentInput). Must not be derived from
+            // `iterations` because fold operations decrement iterations, which would incorrectly
+            // re-trigger the slice on subsequent calls after a fold open/close.
+            let firstLlmCall = !!currentInput;
             while (iterations < this.maxToolIterations) {
                 iterations += 1;
                 const foldSuffix = this.buildFoldSystemPromptSuffix();
@@ -403,14 +503,17 @@ export class ChatDriver extends EventTarget {
                     ? `${this.systemPrompt}${foldSuffix}`
                     : foldSuffix || undefined;
                 const primer = [...((_a = this.primerHistory) !== null && _a !== void 0 ? _a : []), ...(transientPrimer !== null && transientPrimer !== void 0 ? transientPrimer : [])];
-                const baseHistory = iterations === startIteration ? this.history.slice(0, -1) : this.history;
+                const baseHistory = firstLlmCall ? this.history.slice(0, -1) : this.history;
+                firstLlmCall = false;
                 const historyForProvider = this.providerHistoryTransform
                     ? this.providerHistoryTransform([...baseHistory])
                     : baseHistory;
                 const historyForCall = [...primer, ...historyForProvider];
                 const systemPrompt = malformedAttempts > 0
                     ? `${baseSystemPrompt !== null && baseSystemPrompt !== void 0 ? baseSystemPrompt : ''}\n\nIMPORTANT: Use only the structured function-call API to invoke tools. Do not write Python code or use Python-style syntax to call tools.`
-                    : baseSystemPrompt;
+                    : emptyResponseAttempts > 0
+                        ? `${baseSystemPrompt !== null && baseSystemPrompt !== void 0 ? baseSystemPrompt : ''}\n\nIMPORTANT: You must respond to the user's message. Call the appropriate tool or provide a text response — do not return an empty response.`
+                        : baseSystemPrompt;
                 const options = {
                     systemPrompt,
                     // Strip fold-only properties (foldEvent, foldPath) before sending to provider
@@ -443,9 +546,9 @@ export class ChatDriver extends EventTarget {
                 const isThinkingStep = response.content && ((_b = response.toolCalls) === null || _b === void 0 ? void 0 : _b.length);
                 const isEmptyResponse = !((_c = response.content) === null || _c === void 0 ? void 0 : _c.trim()) && !((_d = response.toolCalls) === null || _d === void 0 ? void 0 : _d.length);
                 if (isEmptyResponse) {
-                    malformedAttempts += 1;
-                    if (malformedAttempts < MAX_MALFORMED_RETRIES) {
-                        logger.warn(`ChatDriver: empty model response, retrying (${malformedAttempts}/${MAX_MALFORMED_RETRIES})`);
+                    emptyResponseAttempts += 1;
+                    if (emptyResponseAttempts < MAX_EMPTY_RESPONSE_RETRIES) {
+                        logger.warn(`ChatDriver: empty model response, retrying (${emptyResponseAttempts}/${MAX_EMPTY_RESPONSE_RETRIES})`);
                         iterations -= 1;
                         continue;
                     }
@@ -542,11 +645,14 @@ export class ChatDriver extends EventTarget {
                         }
                         // Real tool execution
                         try {
-                            const result = yield handler(tc.args, {
-                                requestInteraction: (componentName, data) => this.requestInteraction(componentName, data),
-                            });
+                            const traceCapture = {};
+                            const result = yield handler(tc.args, this.buildHandlerContext(traceCapture));
                             const content = typeof result === 'string' ? result : JSON.stringify(result);
-                            executedById.set(tc.id, { toolCallId: tc.id, content });
+                            executedById.set(tc.id, {
+                                toolCallId: tc.id,
+                                content,
+                                subAgentTrace: traceCapture.trace,
+                            });
                             anyRealToolExecuted = true;
                         }
                         catch (e) {
@@ -594,7 +700,7 @@ export class ChatDriver extends EventTarget {
                     const tcMsg = this.history[tcMsgIdx];
                     const availableToolNames = Object.keys(this.toolHandlers);
                     const annotatedCalls = tcMsg.toolCalls.map((tc) => {
-                        var _a, _b, _c, _d;
+                        var _a, _b, _c, _d, _e;
                         const isFoldOpen = !!this.getFold(tc.name) ||
                             (
                             // Was a fold facade at time of the call (now the tool set has changed)
@@ -608,7 +714,7 @@ export class ChatDriver extends EventTarget {
                                     ? 'close'
                                     : undefined, 
                             // Use the fold path that was active at the START of this iteration (before any opens/closes)
-                            foldPath: !isFoldOpen && !isFoldClose && foldPath.length > 0 ? foldPath : undefined, unknown: isUnknown || undefined, availableTools: isUnknown ? availableToolNames : undefined });
+                            foldPath: !isFoldOpen && !isFoldClose && foldPath.length > 0 ? foldPath : undefined, unknown: isUnknown || undefined, availableTools: isUnknown ? availableToolNames : undefined, subAgentTrace: (_e = executedById.get(tc.id)) === null || _e === void 0 ? void 0 : _e.subAgentTrace });
                     });
                     this.history[tcMsgIdx] = Object.assign(Object.assign({}, tcMsg), { toolCalls: annotatedCalls });
                     this.dispatchEvent(new CustomEvent('history-updated', {
@@ -628,6 +734,11 @@ export class ChatDriver extends EventTarget {
                     const { summary, remaining_task: remainingTask } = firstContinuation.args;
                     return { reason: 'agent-handoff', summary, remainingTask };
                 }
+                // Sub-agent early exit — checked here so the exit point mirrors the
+                // system-call pattern above. Set by completeSubAgent() in a tool handler.
+                if (this.subAgentCompletion) {
+                    return { reason: 'done' };
+                }
                 currentInput = '';
             }
             if (iterations >= this.maxToolIterations) {

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -1,4 +1,5 @@
 import { __awaiter } from "tslib";
+import { transformHistoryForAgent } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { ChatDriver, REQUEST_CONTINUATION_TOOL } from '../chat-driver/chat-driver';
 const DEFAULT_MAX_HANDOFFS = 3;
@@ -35,25 +36,6 @@ function buildFallbackSystemPrompt(fallback, specialists) {
     }
     return `You are a helpful assistant. You cannot directly help with the user's request, but the following specialists are available:\n\n${agentList}\n\nPolitely let the user know what you can help with and invite them to rephrase their request.`;
 }
-/**
- * Prepares history for the LLM only: masks tool call args and results from other
- * agents so the active specialist is not confused by tools it does not have.
- * Canonical history in `ChatDriver` stays unmasked for UI and logging.
- */
-function transformHistoryForAgent(history, agentName) {
-    return history.map((msg) => {
-        var _a;
-        if (!msg.agentName || msg.agentName === agentName)
-            return msg;
-        if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
-            return Object.assign(Object.assign({}, msg), { toolCalls: msg.toolCalls.map((tc) => (Object.assign(Object.assign({}, tc), { args: {} }))) });
-        }
-        if (msg.toolResult) {
-            return Object.assign(Object.assign({}, msg), { toolResult: Object.assign(Object.assign({}, msg.toolResult), { content: "[other agent's tool result omitted]" }) });
-        }
-        return msg;
-    });
-}
 /**
  * Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`
  * and `ChatDriver`, classifying each user message and routing it to the right
@@ -80,10 +62,16 @@ export class OrchestratingDriver extends EventTarget {
         this.fallback = rawFallback
             ? Object.assign(Object.assign({}, rawFallback), { systemPrompt: buildFallbackSystemPrompt(rawFallback, this.specialists) }) : undefined;
         this.chatDriver = new ChatDriver(aiProvider, {}, [], undefined, undefined, options.maxToolIterations, options.maxFoldOperations);
-        // Proxy history-updated events from the shared driver
+        // Proxy events from the shared driver
         this.chatDriver.addEventListener('history-updated', (e) => {
             this.dispatchEvent(new CustomEvent('history-updated', { detail: e.detail }));
         });
+        this.chatDriver.addEventListener('sub-agent-history-updated', (e) => {
+            this.dispatchEvent(new CustomEvent('sub-agent-history-updated', { detail: e.detail }));
+        });
+        this.chatDriver.addEventListener('sub-agent-stop', (e) => {
+            this.dispatchEvent(new CustomEvent('sub-agent-stop', { detail: e.detail }));
+        });
     }
     resolveInteraction(interactionId, result) {
         this.chatDriver.resolveInteraction(interactionId, result);

package/dist/esm/config/config.js

@@ -1 +1,18 @@
-export {};
+/**
+ * Identity helper that infers the narrowest possible type for an agent config,
+ * preserving string literal types (including `name`) without requiring `as const`.
+ *
+ * Use this when you need `typeof myAgent` to carry the literal `name` type —
+ * for example, when wiring `ChatToolHandlers<typeof myAgent>`.
+ *
+ * ```ts
+ * const myAgent = defineAgent({ name: 'my_agent', ... });
+ * type Handlers = ChatToolHandlers<typeof myAgent>;
+ * // requestSubAgent name param is now typed as 'my_agent'
+ * ```
+ *
+ * @beta
+ */
+export function defineAgent(config) {
+    return config;
+}

package/dist/esm/main/main.js

@@ -51,6 +51,12 @@ const MODEL_CONTEXT_LIMITS = {
 };
 // Register supporting components when the main component module is imported.
 avoidTreeShaking(AiChatMarkdown, AiChatInteractionWrapper, AiHaloOverlay, AiChatBubble, AiActivityHalo, ChatSuggestions);
+/** Recursively strips `toolHandlers` from an agent and all its sub-agents. */
+function stripHandlers(agent) {
+    const { toolHandlers: _, subAgents } = agent, rest = __rest(agent, ["toolHandlers", "subAgents"]);
+    return (subAgents === null || subAgents === void 0 ? void 0 : subAgents.length)
+        ? Object.assign(Object.assign({}, rest), { subAgents: subAgents.map(stripHandlers) }) : rest;
+}
 /**
  * Foundation AI Assistant component.
  *
@@ -112,17 +118,12 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.activeAgent;
     }
     set activeAgent(value) {
-        var _a, _b;
-        // Strip toolHandlers before storing — functions are non-serializable and Redux
-        // serializable-state middleware will warn. toolHandlers are never read back from
-        // the store; they are always sourced from this.agents when the driver is built.
-        if (value) {
-            const { toolHandlers: _ } = value, serializable = __rest(value, ["toolHandlers"]);
-            (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setActiveAgent(serializable);
-        }
-        else {
-            (_b = this._sessionRef) === null || _b === void 0 ? void 0 : _b.actions.aiAssistant.setActiveAgent(undefined);
-        }
+        var _a;
+        // Strip toolHandlers recursively before storing — functions are non-serializable
+        // and Redux serializable-state middleware will warn. toolHandlers are never read
+        // back from the store; they are always sourced from this.agents when the driver
+        // is built.
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setActiveAgent(value ? stripHandlers(value) : undefined);
     }
     get suggestionsState() {
         var _a, _b;
@@ -168,6 +169,22 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         var _a;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setEnabledAnimations(value);
     }
+    get liveSubAgentTrace() {
+        var _a, _b;
+        return (_b = (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.liveSubAgentTrace) !== null && _b !== void 0 ? _b : [];
+    }
+    set liveSubAgentTrace(value) {
+        var _a;
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setLiveSubAgentTrace(value);
+    }
+    get liveSubAgentName() {
+        var _a, _b;
+        return (_b = (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.liveSubAgentName) !== null && _b !== void 0 ? _b : null;
+    }
+    set liveSubAgentName(value) {
+        var _a;
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setLiveSubAgentName(value);
+    }
     /** Most recent prompt token count from the AI provider, if available. */
     get contextTokens() {
         var _a;
@@ -355,8 +372,23 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.messages = [...e.detail];
         };
         driver.addEventListener('history-updated', onHistoryUpdated);
+        const onSubAgentHistoryUpdated = (e) => {
+            const { agentName, history } = e.detail;
+            this.liveSubAgentName = agentName;
+            // structuredClone so Immer freezes an independent copy, not the child
+            // driver's own history array (which is still being mutated by the tool loop).
+            this.liveSubAgentTrace = structuredClone(history);
+        };
+        const onSubAgentStop = () => {
+            this.liveSubAgentTrace = [];
+            this.liveSubAgentName = null;
+        };
+        driver.addEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated);
+        driver.addEventListener('sub-agent-stop', onSubAgentStop);
         const cleanups = [
             () => driver.removeEventListener('history-updated', onHistoryUpdated),
+            () => driver.removeEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated),
+            () => driver.removeEventListener('sub-agent-stop', onSubAgentStop),
         ];
         if (driver instanceof OrchestratingDriver) {
             const onOrchStart = () => {

package/dist/esm/main/main.styles.js

@@ -445,6 +445,68 @@ export const styles = css `
     padding-left: 8px;
   }
 
+  .live-sub-agent-trace {
+    animation: slide-in-left 0.25s ease-out;
+    border-left: 2px solid var(--neutral-stroke-rest);
+    padding: 4px 8px;
+    margin: 4px 0;
+    opacity: 80%;
+  }
+
+  .live-sub-agent-name {
+    font-family: monospace;
+    font-size: 0.8em;
+    opacity: 70%;
+    font-style: italic;
+    display: block;
+    margin-bottom: 2px;
+  }
+
+  .sub-agent-trace {
+    margin-top: 6px;
+    border-left: 2px solid var(--neutral-stroke-rest);
+    padding-left: 8px;
+  }
+
+  .sub-agent-trace-summary {
+    font-family: monospace;
+    font-size: 0.85em;
+    opacity: 70%;
+    cursor: pointer;
+    user-select: none;
+    padding: 2px 0;
+  }
+
+  .sub-agent-trace-summary:hover {
+    opacity: 100%;
+  }
+
+  .sub-agent-message {
+    font-family: monospace;
+    font-size: 0.85em;
+    margin-top: 4px;
+  }
+
+  .sub-agent-assistant {
+    opacity: 85%;
+    white-space: pre-wrap;
+  }
+
+  .sub-agent-tool-call {
+    opacity: 60%;
+  }
+
+  .sub-agent-tool-name::before {
+    content: '⚙ ';
+  }
+
+  .sub-agent-tool-result {
+    opacity: 50%;
+    border-left: 1px solid var(--neutral-stroke-rest);
+    padding-left: 6px;
+    white-space: pre-wrap;
+  }
+
   .input-row {
     display: flex;
     gap: calc(var(--design-unit) * 2px);