@onereach/step-voice 7.0.40 → 7.0.41-subagents.1

package/dst/Subagent Tools Handler.d.ts

@@ -0,0 +1,10 @@
+import VoiceStep from './voice';
+interface INPUT {
+    subagentName?: string;
+}
+export default class SubagentToolsHandler extends VoiceStep<Partial<INPUT>> {
+    runStep(): Promise<void>;
+    private findExitByLabel;
+    exitToThread(): Promise<void>;
+}
+export {};

package/dst/Subagent Tools Handler.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const voice_1 = tslib_1.__importDefault(require("./voice"));
+class SubagentToolsHandler extends voice_1.default {
+    async runStep() {
+        const call = await this.fetchData();
+        let ctx = null;
+        try {
+            ctx = await this.thread.get(`__voiceAgentContext_${this.thread.id}`);
+        }
+        catch {
+            ctx = null;
+        }
+        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();
+        });
+    }
+    findExitByLabel(label) {
+        const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
+        return exit?.id;
+    }
+    async exitToThread() {
+        const result = this.state.result;
+        await this.thread.set(`__voiceAgentContext_${this.thread.id}`, result);
+        this.thread.exitStep(this.state.exitStep, result);
+    }
+}
+exports.default = SubagentToolsHandler;

package/dst/Voice Agent.d.ts

@@ -30,6 +30,19 @@ interface Handler {
     parameters: string;
     feedback?: PerToolConfig;
 }
+interface SubagentTool {
+    name: string;
+    description: string;
+    parameters: string;
+    feedback?: PerToolConfig;
+}
+interface Subagent {
+    id: string;
+    name: string;
+    system_instruction: string;
+    tools: SubagentTool[];
+    exitId?: string;
+}
 interface AgentSystemToolConfig {
     name: string;
     description?: string;
@@ -43,6 +56,7 @@ interface AgentServiceConfig {
 }
 interface INPUT {
     handlers: Handler[];
+    subagents: Subagent[];
     system_instruction: string;
     developer_messages: string[];
     greeting_message: string;
@@ -72,7 +86,16 @@ 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 findExitByLabel;
     private validateToolFeedback;
     private isStepFlagEnabled;

package/dst/Voice Agent.js

@@ -11,8 +11,12 @@ class VoiceAgent extends voice_1.default {
                 case 'tool_call': {
                     if (event.params.type !== 'tool_call')
                         return;
-                    const cb = this.thread.takeCallback();
                     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 exitId = this.findExitByLabel(name) ?? this.getExitStepId('tool_call');
@@ -52,34 +56,11 @@ class VoiceAgent extends voice_1.default {
             }
         });
         this.triggers.otherwise(async () => {
-            const { handlers = [], system_instruction = '', developer_messages = [], greeting_message = '', prevent_greeting_interruption = false, idle_detection_enabled = false, idle_timeout_secs = 8, idle_max_retries = 3, idle_prompts = [], idle_goodbye_message = '', dtmf_enabled = false, dtmf_timeout = 2, dtmf_termination_digit = '#', dtmf_prefix = 'DTMF: ', custom_config_enabled = false, agent_url_overwritten = false, tool_feedback, soft_timeout, system_tools, agent_url = '', mode = '', stt = {}, llm = {}, tts = {}, realtime = {} } = this.data;
+            const { handlers = [], subagents = [], system_instruction = '', developer_messages = [], greeting_message = '', prevent_greeting_interruption = false, idle_detection_enabled = false, idle_timeout_secs = 8, idle_max_retries = 3, idle_prompts = [], idle_goodbye_message = '', dtmf_enabled = false, dtmf_timeout = 2, dtmf_termination_digit = '#', dtmf_prefix = 'DTMF: ', custom_config_enabled = false, agent_url_overwritten = false, tool_feedback, soft_timeout, system_tools, agent_url = '', mode = '', stt = {}, llm = {}, tts = {}, realtime = {} } = this.data;
             if (lodash_1.default.isEmpty(system_instruction)) {
                 this.throwError(new Error('Voice Agent: system instruction is required'));
             }
-            const tools = handlers.map(h => {
-                let parameters = h.parameters;
-                if (typeof parameters === 'string') {
-                    try {
-                        parameters = JSON.parse(parameters);
-                    }
-                    catch {
-                        parameters = {};
-                    }
-                }
-                const tool = {
-                    type: 'function',
-                    name: h.name,
-                    description: h.description,
-                    parameters: parameters || {}
-                };
-                if (h.feedback != null) {
-                    const validatedFeedback = this.validatePerToolFeedback(h.feedback, h.name);
-                    if (validatedFeedback) {
-                        tool.feedback = validatedFeedback;
-                    }
-                }
-                return tool;
-            });
+            const tools = handlers.map(h => this.serializeTool(h));
             const config = {
                 system_instruction,
                 developer_messages,
@@ -87,6 +68,10 @@ class VoiceAgent extends voice_1.default {
                 prevent_greeting_interruption,
                 tools
             };
+            const serializedSubagents = this.serializeSubagents(subagents) || [];
+            if (serializedSubagents.length > 0) {
+                config.subagents = serializedSubagents;
+            }
             if (this.isStepFlagEnabled(idle_detection_enabled)) {
                 const timeoutSecs = Number(idle_timeout_secs);
                 const maxRetries = Number(idle_max_retries);
@@ -152,14 +137,88 @@ 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 ?? '')
             .filter(prompt => !lodash_1.default.isEmpty(lodash_1.default.trim(String(prompt))));
     }
+    serializeTool(h) {
+        let parameters = h.parameters;
+        if (typeof parameters === 'string') {
+            try {
+                parameters = JSON.parse(parameters);
+            }
+            catch {
+                parameters = {};
+            }
+        }
+        const tool = {
+            type: 'function',
+            name: h.name,
+            description: h.description,
+            parameters: parameters || {}
+        };
+        if (h.feedback != null) {
+            const validatedFeedback = this.validatePerToolFeedback(h.feedback, h.name);
+            if (validatedFeedback) {
+                tool.feedback = validatedFeedback;
+            }
+        }
+        return tool;
+    }
+    serializeSubagents(subagents) {
+        if (!Array.isArray(subagents))
+            return [];
+        return subagents
+            .filter(sa => sa != null && !lodash_1.default.isEmpty(lodash_1.default.trim(sa.name)))
+            .map(sa => ({
+            name: lodash_1.default.trim(sa.name),
+            system_instruction: sa.system_instruction || '',
+            tools: (sa.tools || [])
+                .filter(t => t != null && !lodash_1.default.isEmpty(lodash_1.default.trim(t.name)))
+                .map(t => this.serializeTool(t))
+        }));
+    }
+    isSubagentExitLabel(label) {
+        const subagents = this.data.subagents || [];
+        return subagents.some(sa => {
+            const name = lodash_1.default.trim(sa?.name || '');
+            return !!name && label === `subagent_${name}`;
+        });
+    }
+    isSubagentTool(toolName) {
+        const subagents = this.data.subagents || [];
+        return subagents.some(sa => (sa?.tools || []).some(t => t && lodash_1.default.trim(t.name) === toolName));
+    }
     findExitByLabel(label) {
         const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
         return exit?.id;

package/package.json

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