@onereach/step-voice 7.0.41-subagents.3 → 7.0.41-subagents.4

package/dst/Subagent Tools Handler.d.ts

@@ -4,6 +4,7 @@ interface INPUT {
 }
 export default class SubagentToolsHandler extends VoiceStep<Partial<INPUT>> {
     runStep(): Promise<void>;
+    private loadToolCallContext;
     private findExitByLabel;
     exitToThread(): Promise<void>;
 }

package/dst/Subagent Tools Handler.js

@@ -6,69 +6,62 @@ const voice_1 = tslib_1.__importDefault(require("./voice"));
 class SubagentToolsHandler extends voice_1.default {
     async runStep() {
         const call = await this.fetchData();
-        let ctx = null;
+        const ctx = await this.loadToolCallContext();
+        const toolName = lodash_1.default.trim(String(ctx.name ?? ''));
+        const subagentName = lodash_1.default.trim(String(ctx.subagent ?? this.data.subagentName ?? ''));
+        const arguments_ = (ctx.arguments && typeof ctx.arguments === 'object')
+            ? ctx.arguments
+            : (ctx[toolName] ?? {});
+        const exitId = toolName ? this.findExitByLabel(toolName) : undefined;
+        this.log.info('Subagent Tools Handler: incoming tool_call', {
+            toolName,
+            subagent: subagentName,
+            exitId,
+            threadId: this.thread.id,
+            hasContext: !lodash_1.default.isEmpty(ctx)
+        });
+        if (!exitId) {
+            this.log.warn('Subagent Tools Handler: no exit for tool_call', {
+                name: toolName,
+                subagent: subagentName,
+                exits: (this.step.exits || []).map((e) => e.label)
+            });
+            this.exitFlow();
+            return;
+        }
+        // Same hop as Voice Agent → tool: fork so Voice Agent Tool Result still
+        // finds __voiceAgentContext_ on the child thread. Do not exitFlow() after
+        // this — that would tear down the parent before the tool thread starts.
+        await this.exitStep(exitId, {
+            [toolName]: arguments_,
+            name: toolName,
+            toolCallId: ctx.toolCallId ?? '',
+            arguments: arguments_,
+            subagent: subagentName,
+            __voicecb: ctx.__voicecb,
+            callId: ctx.callId ?? call.id,
+            callType: ctx.callType ?? call.type,
+            callCallback: ctx.callCallback ?? call.callback
+        }, true);
+    }
+    async loadToolCallContext() {
+        const fromState = (this.state?.result && typeof this.state.result === 'object')
+            ? this.state.result
+            : {};
+        let fromThread = {};
         try {
-            ctx = await this.thread.get(`__voiceAgentContext_${this.thread.id}`);
+            const stored = await this.thread.get(`__voiceAgentContext_${this.thread.id}`);
+            if (stored && typeof stored === 'object')
+                fromThread = stored;
         }
         catch {
-            ctx = null;
+            // key absent on this thread — Voice Agent payload may still be in state.result
         }
-        const callId = ctx?.callId ?? call.id;
-        const callType = ctx?.callType ?? call.type;
-        const callCallback = ctx?.callCallback ?? call.callback;
-        const subagentName = ctx?.subagent ?? ctx?.name ?? this.data.subagentName ?? '';
-        this.triggers.local(`in/voice/${callId}`, async (event) => {
-            switch (event.params.type) {
-                case 'tool_call': {
-                    const eventSubagent = event.params.subagent;
-                    if (eventSubagent && subagentName && eventSubagent !== subagentName) {
-                        return;
-                    }
-                    const cb = this.thread.takeCallback();
-                    const name = event.params.name ?? 'tool_call';
-                    const params = event.params.arguments ?? {};
-                    const toolCallId = event.params.toolCallId ?? '';
-                    const exitId = this.findExitByLabel(name);
-                    if (!exitId) {
-                        return;
-                    }
-                    this.exitStep(exitId, {
-                        [name]: params,
-                        name,
-                        toolCallId,
-                        subagent: subagentName,
-                        __voicecb: cb,
-                        callId,
-                        callType,
-                        callCallback
-                    }, true);
-                    return;
-                }
-                case 'hangup': {
-                    delete this.waits.timeout;
-                    await this.handleHangup(call);
-                    return await this.waitConvEnd();
-                }
-                case 'error': {
-                    delete this.waits.timeout;
-                    const exitId = this.getExitStepId('error');
-                    if (exitId)
-                        return this.exitStep(exitId, { error: event.params.error });
-                    return this.throwError(event.params.error);
-                }
-                case 'cancel':
-                    return this.end();
-            }
-        });
-        this.triggers.otherwise(async () => {
-            if (lodash_1.default.isEmpty(subagentName)) {
-                this.log.warn('Subagent Tools Handler: no subagent context; waiting for tool calls on exits only');
-            }
-            return this.exitFlow();
-        });
+        return { ...fromState, ...fromThread };
     }
     findExitByLabel(label) {
-        const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
+        const needle = lodash_1.default.trim(label);
+        const exit = lodash_1.default.find(this.step.exits, (e) => lodash_1.default.trim(e.label || '') === needle);
         return exit?.id;
     }
     async exitToThread() {

package/dst/Voice Agent.d.ts

@@ -90,16 +90,12 @@ interface INPUT {
 }
 export default class VoiceAgent extends VoiceStep<Partial<INPUT>> {
     runStep(): Promise<void>;
-    /**
-     * Fork a thread per subagent exit so Subagent Tools Handler steps can
-     * register tool_call listeners immediately after agent start.
-     */
-    private spawnSubagentHandlerThreads;
     private normalizeIdlePrompts;
     private serializeTool;
     private serializeSubagents;
-    private isSubagentExitLabel;
-    private isSubagentTool;
+    private findSubagentForTool;
+    private findSubagentByName;
+    private resolveSubagentExit;
     private findExitByLabel;
     private validateToolFeedback;
     private isStepFlagEnabled;

package/dst/Voice Agent.js

@@ -12,24 +12,47 @@ class VoiceAgent extends voice_1.default {
                     if (event.params.type !== 'tool_call')
                         return;
                     const name = event.params.name ?? 'tool_call';
-                    // Subagent tools are handled by pre-spawned Subagent Tools Handler threads.
-                    if (event.params.subagent || this.isSubagentTool(name) || this.isSubagentExitLabel(name)) {
-                        return;
-                    }
                     const cb = this.thread.takeCallback();
                     const params = event.params.arguments ?? {};
                     const toolCallId = event.params.toolCallId ?? '';
+                    const payload = {
+                        [name]: params,
+                        name,
+                        toolCallId,
+                        __voicecb: cb,
+                        callId: call.id,
+                        callType: call.type,
+                        callCallback: call.callback
+                    };
+                    const subagent = this.findSubagentForTool(name)
+                        || this.findSubagentByName(event.params.subagent);
+                    if (subagent) {
+                        const exitId = this.resolveSubagentExit(subagent);
+                        if (exitId) {
+                            this.log.info('Voice Agent: routing tool_call to subagent', {
+                                name,
+                                subagent: subagent.name,
+                                exitId
+                            });
+                            this.exitStep(exitId, {
+                                ...payload,
+                                arguments: params,
+                                subagent: subagent.name
+                            }, true);
+                        }
+                        else {
+                            this.log.warn('no exit for subagent tool_call', {
+                                name,
+                                subagent: subagent.name,
+                                exitId: subagent.exitId,
+                                exits: (this.step.exits || []).map((e) => ({ id: e.id, label: e.label }))
+                            });
+                        }
+                        return;
+                    }
                     const exitId = this.findExitByLabel(name) ?? this.getExitStepId('tool_call');
                     if (exitId) {
-                        this.exitStep(exitId, {
-                            [name]: params,
-                            name,
-                            toolCallId,
-                            __voicecb: cb,
-                            callId: call.id,
-                            callType: call.type,
-                            callCallback: call.callback
-                        }, true);
+                        this.exitStep(exitId, payload, true);
                     }
                     else {
                         this.log.warn('no exit for tool_call', { name });
@@ -137,35 +160,9 @@ class VoiceAgent extends voice_1.default {
                 params.url = agentCustomUrl;
             }
             await this.sendCommands(call, [{ name: 'startAgent', params }]);
-            this.spawnSubagentHandlerThreads(call, subagents);
             return this.exitFlow();
         });
     }
-    /**
-     * Fork a thread per subagent exit so Subagent Tools Handler steps can
-     * register tool_call listeners immediately after agent start.
-     */
-    spawnSubagentHandlerThreads(call, subagents) {
-        if (!Array.isArray(subagents) || subagents.length === 0)
-            return;
-        for (const sa of subagents) {
-            const name = lodash_1.default.trim(sa?.name || '');
-            if (!name)
-                continue;
-            const exitId = sa.exitId || this.findExitByLabel(`subagent_${name}`);
-            if (!exitId) {
-                this.log.warn('Voice Agent: no exit for subagent; handler thread not started', { name });
-                continue;
-            }
-            this.exitStep(exitId, {
-                name,
-                subagent: name,
-                callId: call.id,
-                callType: call.type,
-                callCallback: call.callback
-            }, true);
-        }
-    }
     normalizeIdlePrompts(idlePrompts) {
         return (idlePrompts || [])
             .map(item => typeof item === 'string' ? item : item?.prompt ?? '')
@@ -219,19 +216,29 @@ class VoiceAgent extends voice_1.default {
             return serialized;
         });
     }
-    isSubagentExitLabel(label) {
+    findSubagentForTool(toolName) {
+        const needle = lodash_1.default.trim(toolName);
+        if (!needle)
+            return undefined;
         const subagents = this.data.subagents || [];
-        return subagents.some(sa => {
-            const name = lodash_1.default.trim(sa?.name || '');
-            return !!name && label === `subagent_${name}`;
-        });
+        return subagents.find(sa => (sa?.tools || []).some(t => t && lodash_1.default.trim(String(t.name || '')) === needle));
     }
-    isSubagentTool(toolName) {
-        const subagents = this.data.subagents || [];
-        return subagents.some(sa => (sa?.tools || []).some(t => t && lodash_1.default.trim(t.name) === toolName));
+    findSubagentByName(name) {
+        if (typeof name !== 'string' || lodash_1.default.isEmpty(lodash_1.default.trim(name)))
+            return undefined;
+        const trimmed = lodash_1.default.trim(name);
+        return (this.data.subagents || []).find(sa => lodash_1.default.trim(sa?.name || '') === trimmed);
+    }
+    resolveSubagentExit(subagent) {
+        if (subagent.exitId && this.getExitStepId(subagent.exitId, false)) {
+            return subagent.exitId;
+        }
+        const name = lodash_1.default.trim(subagent.name || '');
+        return this.findExitByLabel(`subagent_${name}`) || this.findExitByLabel(name);
     }
     findExitByLabel(label) {
-        const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
+        const needle = lodash_1.default.trim(label);
+        const exit = lodash_1.default.find(this.step.exits, (e) => lodash_1.default.trim(e.label || '') === needle);
         return exit?.id;
     }
     validateToolFeedback(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onereach/step-voice",
-  "version": "7.0.41-subagents.3",
+  "version": "7.0.41-subagents.4",
   "author": "Roman Zolotarov <roman.zolotarov@onereach.com>",
   "contributors": [
     "Roman Zolotarov",