@onereach/step-voice 7.0.26-agenttimeout.0 → 7.0.26-agenttimeout.10

package/dst/Voice Agent Function Result.d.ts

@@ -2,6 +2,7 @@ import VoiceStep from './voice';
 interface INPUT {
     result: string;
     stopAgent: boolean;
+    functionId?: string;
 }
 export default class VoiceAgentFunctionResult extends VoiceStep<INPUT> {
     runStep(): Promise<void>;

package/dst/Voice Agent Function Result.js

@@ -4,13 +4,70 @@ 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 { result, stopAgent, functionId: inputFunctionId } = this.data;
+        this.log.info("VoiceAgentFunctionResult: start", {
+            threadId: this.thread.id,
+            inputFunctionId,
+            stateKeys: Object.keys(this.state || {}),
+            stateDirect: this.state?.direct,
+            stateResultFunctionId: this.state?.result?.functionId,
+            stateResultCallId: this.state?.result?.callId,
+        });
+        // Attempt to get functionId from multiple sources to handle parallel function calls.
+        // Session storage is race-prone when multiple function_call threads run concurrently.
+        const threadStateFunctionId = this.state?.result?.functionId;
+        const resolvedFunctionId = inputFunctionId || threadStateFunctionId;
+        this.log.info("VoiceAgentFunctionResult: resolvedFunctionId", {
+            resolvedFunctionId,
+            source: inputFunctionId ? 'data.functionId' : threadStateFunctionId ? 'state.result.functionId' : 'none',
+        });
+        let ctx = null;
+        let ctxSource = 'none';
+        // Priority 1: functionId-keyed context (race-safe, unique per function call)
+        if (resolvedFunctionId) {
+            ctx = await this.thread.get(`__voiceAgentContext_fn_${resolvedFunctionId}`);
+            if (ctx) {
+                ctxSource = `__voiceAgentContext_fn_${resolvedFunctionId}`;
+                this.log.info("VoiceAgentFunctionResult: ctx from fn-keyed store", { ctxSource, functionId: ctx.functionId });
+            }
+            else {
+                this.log.info("VoiceAgentFunctionResult: fn-keyed store miss", { key: `__voiceAgentContext_fn_${resolvedFunctionId}` });
+            }
+        }
+        // Priority 2: Thread-specific context
+        if (!ctx) {
+            ctx = await this.thread.get(`__voiceAgentContext_${this.thread.id}`);
+            if (ctx) {
+                ctxSource = `__voiceAgentContext_${this.thread.id}`;
+                this.log.info("VoiceAgentFunctionResult: ctx from thread-specific store", { ctxSource, functionId: ctx.functionId });
+            }
+            else {
+                this.log.info("VoiceAgentFunctionResult: thread-specific store miss", { key: `__voiceAgentContext_${this.thread.id}` });
+            }
+        }
+        // Priority 3: Use state.result directly if it has callId (from exitToThread → exitStep chain)
+        if (!ctx && this.state?.result?.callId) {
+            ctx = this.state.result;
+            ctxSource = 'state.result';
+            this.log.info("VoiceAgentFunctionResult: ctx from state.result", { functionId: ctx.functionId, callId: ctx.callId });
+        }
+        // Priority 4: Shared session context (backward compat, NOT race-safe for parallel calls)
+        if (!ctx) {
+            ctx = await this.thread.get('__voiceAgentContext') ?? {};
+            ctxSource = '__voiceAgentContext (shared session)';
+            this.log.info("VoiceAgentFunctionResult: ctx from shared session", { functionId: ctx?.functionId, callId: ctx?.callId });
+        }
         const { callId, callCallback, name: functionName, functionId } = ctx;
-        const { result, stopAgent } = this.data;
+        this.log.info("VoiceAgentFunctionResult: resolved context", {
+            ctxSource,
+            callId,
+            functionId,
+            functionName,
+            hasCallback: !!callCallback,
+        });
         if (!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 params = {
             functionName: functionName,
             functionId: functionId,
@@ -27,7 +84,7 @@ class VoiceAgentFunctionResult extends voice_1.default {
                 commands: [{ name: 'agentFunctionResult', params }]
             }
         };
-        this.log.info("Voice Agent Function Result", event);
+        this.log.info("VoiceAgentFunctionResult: sending", { functionId, functionName, callId });
         await this.thread.eventManager.emit(event, {
             target: callCallback,
             invocationType: 'async',

package/dst/Voice Agent.js

@@ -111,7 +111,7 @@ class VoiceAgent extends voice_1.default {
                         this.throwError(new Error(`Voice Agent: unknown mode "${mode}"`));
                 }
             }
-            if (this.isStepFlagEnabled(tool_feedback?.enabled)) {
+            if (this.isStepFlagEnabled(tool_feedback?.enabled) && tools.length > 0) {
                 const validatedFeedback = this.validateToolFeedback(tool_feedback);
                 if (validatedFeedback) {
                     config.tool_feedback = validatedFeedback;
@@ -142,48 +142,50 @@ class VoiceAgent extends voice_1.default {
     }
     validateToolFeedback(config) {
         if (config == null || typeof config !== 'object')
-            return undefined;
+            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 undefined;
+            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 undefined;
+            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 undefined;
+            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 undefined;
+            return null;
         }
         // Validate delay_seconds
-        const delay = cfg.delay_seconds;
-        if (typeof delay !== 'number' || !Number.isFinite(delay) || delay <= 0 || delay > 30) {
+        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 undefined;
+            return null;
         }
-        // Validate pre_tool_speech_phrases
+        // Validate pre_tool_speech_phrases (only required when mode is 'static')
         const phrases = cfg.pre_tool_speech_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 tool_feedback.pre_tool_speech_phrases — feedback config excluded');
-            return undefined;
+        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: phrases,
+            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
@@ -216,7 +218,7 @@ class VoiceAgent extends voice_1.default {
         const result = {};
         if ('delay_seconds' in raw && raw.delay_seconds != null) {
             const delay = Number(raw.delay_seconds);
-            if (!Number.isFinite(delay) || delay <= 0 || delay > 30) {
+            if (delay <= 0 || delay > 30) {
                 this.log.warn(`Voice Agent: invalid feedback.delay_seconds for tool "${toolName}" — per-tool feedback excluded`);
                 return null;
             }
@@ -252,8 +254,8 @@ class VoiceAgent extends voice_1.default {
         if (config == null || typeof config !== 'object' || Array.isArray(config))
             return null;
         const cfg = config;
-        const timeoutSeconds = cfg.timeout_seconds;
-        if (typeof timeoutSeconds !== 'number' || !Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0 || timeoutSeconds > 30) {
+        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;
         }
@@ -294,8 +296,22 @@ 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;
+        this.log.info("VoiceAgent.exitToThread: writing context", {
+            threadId: this.thread.id,
+            functionId: result?.functionId,
+            callId: result?.callId,
+            name: result?.name,
+        });
+        await this.thread.set(`__voiceAgentContext_${this.thread.id}`, result);
+        await this.thread.set('__voiceAgentContext', result);
+        if (result?.functionId) {
+            await this.thread.set(`__voiceAgentContext_fn_${result.functionId}`, result);
+            this.log.info("VoiceAgent.exitToThread: wrote fn-keyed context", {
+                key: `__voiceAgentContext_fn_${result.functionId}`,
+            });
+        }
+        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-agenttimeout.0",
+  "version": "7.0.26-agenttimeout.10",
   "author": "Roman Zolotarov <roman.zolotarov@onereach.com>",
   "contributors": [
     "Roman Zolotarov",