@onereach/step-voice 7.0.26 → 7.0.27

package/dst/Voice Agent Function Result.js

@@ -4,31 +4,27 @@ const tslib_1 = require("tslib");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
 class VoiceAgentFunctionResult extends voice_1.default {
     async runStep() {
-        const ctx = await this.thread.get('__voiceAgentContext') ?? {};
-        const { callId, callCallback, name: functionName, functionId } = ctx;
         const { result, stopAgent } = this.data;
-        if (!callId) {
+        const ctx = await this.thread.get(`__voiceAgentContext_${this.thread.id}`);
+        if (!ctx?.callId) {
             throw new Error('Voice Agent Function Result: missing call context (must be placed on a Voice Agent function exit)');
         }
-        this.log.info("Voice Agent Function Result Params", ctx);
+        const { callId, callCallback, name: functionName, functionId } = ctx;
+        this.log.info("Voice Agent Function Result", { functionId, callId, threadId: this.thread.id });
         const params = {
-            functionName: functionName,
-            functionId: functionId,
-            result: result,
-            options: {
-                stop: stopAgent
-            }
+            functionName,
+            functionId,
+            result,
+            options: { stop: stopAgent }
         };
-        const event = {
+        await this.thread.eventManager.emit({
             target: this.helpers.providersAccountId,
             name: 'out/voice/voicer',
             params: {
                 id: callId,
                 commands: [{ name: 'agentFunctionResult', params }]
             }
-        };
-        this.log.info("Voice Agent Function Result", event);
-        await this.thread.eventManager.emit(event, {
+        }, {
             target: callCallback,
             invocationType: 'async',
             timeout: 5000

package/dst/Voice Agent.d.ts

@@ -1,8 +1,34 @@
 import VoiceStep from './voice';
+type PreToolSpeechMode = 'auto' | 'static' | 'off';
+type ToolCallSound = 'typing' | 'none';
+type ToolCallSoundBehavior = 'always' | 'with_pre_speech';
+type SoftTimeoutMode = 'static' | 'auto';
+interface ToolCallFeedbackConfig {
+    enabled: boolean;
+    pre_tool_speech: PreToolSpeechMode;
+    pre_tool_speech_phrases: string[];
+    tool_call_sound: ToolCallSound;
+    tool_call_sound_behavior: ToolCallSoundBehavior;
+    delay_seconds: number;
+}
+interface PerToolConfig {
+    enabled?: boolean | null;
+    pre_tool_speech?: PreToolSpeechMode | null;
+    pre_tool_speech_phrases?: string[] | null;
+    tool_call_sound?: ToolCallSound | null;
+    tool_call_sound_behavior?: ToolCallSoundBehavior | null;
+    delay_seconds?: number | null;
+}
+interface SoftTimeoutConfig {
+    timeout_seconds: number;
+    phrases: string[];
+    mode: SoftTimeoutMode;
+}
 interface Handler {
     name: string;
     description: string;
     parameters: string;
+    feedback?: PerToolConfig;
 }
 interface AgentServiceConfig {
     provider: string;
@@ -35,14 +61,19 @@ interface INPUT {
     llm: Partial<AgentServiceConfig>;
     tts: Partial<AgentServiceConfig>;
     realtime: Partial<AgentServiceConfig>;
+    tool_feedback?: ToolCallFeedbackConfig;
+    soft_timeout?: SoftTimeoutConfig;
 }
 export default class VoiceAgent extends VoiceStep<Partial<INPUT>> {
     runStep(): Promise<void>;
     private normalizeIdlePrompts;
     private findExitByLabel;
+    private validateToolFeedback;
     private isStepFlagEnabled;
     private isValidAgentUrl;
     private buildAgentServiceConfig;
+    private validatePerToolFeedback;
+    private validateSoftTimeout;
     private parseAgentServiceOptions;
     exitToThread(): Promise<void>;
 }

package/dst/Voice Agent.js

@@ -17,7 +17,15 @@ class VoiceAgent extends voice_1.default {
                     const functionId = event.params.functionId ?? '';
                     const exitId = this.findExitByLabel(name) ?? this.getExitStepId('function_call');
                     if (exitId) {
-                        this.exitStep(exitId, { [name]: params, name, functionId, __voicecb: cb, callId: call.id, callType: call.type, callCallback: call.callback }, true);
+                        this.exitStep(exitId, {
+                            [name]: params,
+                            name,
+                            functionId,
+                            __voicecb: cb,
+                            callId: call.id,
+                            callType: call.type,
+                            callCallback: call.callback
+                        }, true);
                     }
                     else {
                         this.log.warn('no exit for function_call', { name });
@@ -34,7 +42,7 @@ 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, agent_url = '', mode = '', stt = {}, llm = {}, tts = {}, realtime = {} } = this.data;
+            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, 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'));
             }
@@ -48,7 +56,19 @@ class VoiceAgent extends voice_1.default {
                         parameters = {};
                     }
                 }
-                return { type: 'function', name: h.name, description: h.description, parameters: 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 config = {
                 system_instruction,
@@ -102,6 +122,18 @@ class VoiceAgent extends voice_1.default {
                         this.throwError(new Error(`Voice Agent: unknown mode "${mode}"`));
                 }
             }
+            if (this.isStepFlagEnabled(tool_feedback?.enabled) && tools.length > 0) {
+                const validatedFeedback = this.validateToolFeedback(tool_feedback);
+                if (validatedFeedback) {
+                    config.tool_feedback = validatedFeedback;
+                }
+            }
+            if (soft_timeout != null) {
+                const validatedSoftTimeout = this.validateSoftTimeout(soft_timeout);
+                if (validatedSoftTimeout) {
+                    config.soft_timeout = validatedSoftTimeout;
+                }
+            }
             const params = { config };
             if (agentCustomUrl) {
                 params.url = agentCustomUrl;
@@ -119,6 +151,57 @@ class VoiceAgent extends voice_1.default {
         const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
         return exit?.id;
     }
+    validateToolFeedback(config) {
+        if (config == null || typeof config !== 'object')
+            return null;
+        const cfg = config;
+        // If enabled is not boolean true, silently return undefined (disabled case)
+        if (typeof cfg.enabled !== 'boolean' || cfg.enabled !== true)
+            return null;
+        // Validate pre_tool_speech
+        const validPreToolSpeech = ['auto', 'static', 'off'];
+        if (!validPreToolSpeech.includes(cfg.pre_tool_speech)) {
+            this.log.warn('Voice Agent: invalid tool_feedback.pre_tool_speech — feedback config excluded');
+            return null;
+        }
+        // Validate tool_call_sound
+        const validToolCallSound = ['typing', 'none'];
+        if (!validToolCallSound.includes(cfg.tool_call_sound)) {
+            this.log.warn('Voice Agent: invalid tool_feedback.tool_call_sound — feedback config excluded');
+            return null;
+        }
+        // Validate tool_call_sound_behavior
+        const validToolCallSoundBehavior = ['always', 'with_pre_speech'];
+        if (!validToolCallSoundBehavior.includes(cfg.tool_call_sound_behavior)) {
+            this.log.warn('Voice Agent: invalid tool_feedback.tool_call_sound_behavior — feedback config excluded');
+            return null;
+        }
+        // Validate delay_seconds
+        const delay = Number(cfg.delay_seconds);
+        if (delay <= 0 || delay > 30) {
+            this.log.warn('Voice Agent: invalid tool_feedback.delay_seconds — feedback config excluded');
+            return null;
+        }
+        // Validate pre_tool_speech_phrases (only required when mode is 'static')
+        const phrases = cfg.pre_tool_speech_phrases;
+        if (cfg.pre_tool_speech === 'static') {
+            if (!Array.isArray(phrases) ||
+                phrases.length < 1 ||
+                phrases.length > 20 ||
+                !phrases.every((p) => typeof p === 'string' && p.trim().length > 0)) {
+                this.log.warn('Voice Agent: invalid tool_feedback.pre_tool_speech_phrases — feedback config excluded');
+                return null;
+            }
+        }
+        return {
+            enabled: true,
+            pre_tool_speech: cfg.pre_tool_speech,
+            pre_tool_speech_phrases: (Array.isArray(phrases) ? phrases : []),
+            tool_call_sound: cfg.tool_call_sound,
+            tool_call_sound_behavior: cfg.tool_call_sound_behavior,
+            delay_seconds: delay
+        };
+    }
     isStepFlagEnabled(value) {
         return value === true || value === 'true';
     }
@@ -138,6 +221,75 @@ class VoiceAgent extends voice_1.default {
             options: this.parseAgentServiceOptions(label, service.options)
         };
     }
+    validatePerToolFeedback(config, toolName) {
+        if (config == null || typeof config !== 'object' || Array.isArray(config)) {
+            return null;
+        }
+        const raw = config;
+        const result = {};
+        if ('delay_seconds' in raw && raw.delay_seconds != null) {
+            const delay = Number(raw.delay_seconds);
+            if (delay <= 0 || delay > 30) {
+                this.log.warn(`Voice Agent: invalid feedback.delay_seconds for tool "${toolName}" — per-tool feedback excluded`);
+                return null;
+            }
+            result.delay_seconds = delay;
+        }
+        if ('pre_tool_speech' in raw && raw.pre_tool_speech != null) {
+            const valid = ['auto', 'static', 'off'];
+            if (!valid.includes(raw.pre_tool_speech)) {
+                this.log.warn(`Voice Agent: invalid feedback.pre_tool_speech for tool "${toolName}" — per-tool feedback excluded`);
+                return null;
+            }
+            result.pre_tool_speech = raw.pre_tool_speech;
+        }
+        if ('tool_call_sound' in raw && raw.tool_call_sound != null) {
+            const valid = ['typing', 'none'];
+            if (!valid.includes(raw.tool_call_sound)) {
+                this.log.warn(`Voice Agent: invalid feedback.tool_call_sound for tool "${toolName}" — per-tool feedback excluded`);
+                return null;
+            }
+            result.tool_call_sound = raw.tool_call_sound;
+        }
+        if ('tool_call_sound_behavior' in raw && raw.tool_call_sound_behavior != null) {
+            const valid = ['always', 'with_pre_speech'];
+            if (!valid.includes(raw.tool_call_sound_behavior)) {
+                this.log.warn(`Voice Agent: invalid feedback.tool_call_sound_behavior for tool "${toolName}" — per-tool feedback excluded`);
+                return null;
+            }
+            result.tool_call_sound_behavior = raw.tool_call_sound_behavior;
+        }
+        return result;
+    }
+    validateSoftTimeout(config) {
+        if (config == null || typeof config !== 'object' || Array.isArray(config))
+            return null;
+        const cfg = config;
+        const timeoutSeconds = Number(cfg.timeout_seconds);
+        if (timeoutSeconds <= 0 || timeoutSeconds > 30) {
+            this.log.warn('Voice Agent: invalid soft_timeout.timeout_seconds — soft timeout config excluded');
+            return null;
+        }
+        const validModes = ['static', 'auto'];
+        if (!validModes.includes(cfg.mode)) {
+            this.log.warn('Voice Agent: invalid soft_timeout.mode — soft timeout config excluded');
+            return null;
+        }
+        // Validate phrases
+        const phrases = cfg.phrases;
+        if (!Array.isArray(phrases) ||
+            phrases.length < 1 ||
+            phrases.length > 20 ||
+            !phrases.every((p) => typeof p === 'string' && p.trim().length > 0)) {
+            this.log.warn('Voice Agent: invalid soft_timeout.phrases — soft timeout config excluded');
+            return null;
+        }
+        return {
+            timeout_seconds: timeoutSeconds,
+            phrases: phrases,
+            mode: cfg.mode
+        };
+    }
     parseAgentServiceOptions(label, options) {
         if (options == null || options === '')
             return undefined;
@@ -155,8 +307,9 @@ class VoiceAgent extends voice_1.default {
         return options;
     }
     async exitToThread() {
-        await this.thread.set('__voiceAgentContext', this.state.result);
-        this.thread.exitStep(this.state.exitStep, this.state.result);
+        const result = this.state.result;
+        await this.thread.set(`__voiceAgentContext_${this.thread.id}`, result);
+        this.thread.exitStep(this.state.exitStep, result);
     }
 }
 exports.default = VoiceAgent;

package/dst/voice.js

@@ -18,8 +18,7 @@ class VoiceStep extends step_1.default {
         if (this.cache != null) {
             if (this.thread.id !== this.dataThreadId)
                 this.thread.refThread(this.dataThreadId);
-            if (!this.state.direct)
-                await this.handleHeartbeat(this.cache);
+            await this.handleHeartbeat(this.cache);
         }
     }
     exitStep(exitId, data, byThread = false) {

package/package.json

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