@onereach/step-voice 7.0.30 → 7.0.32-VOIC1701.2

package/dst/Update Voice Agent.d.ts

@@ -0,0 +1,41 @@
+import VoiceStep from './voice';
+type SystemInstructionMode = 'append' | 'replace' | 'off';
+interface Tool {
+    name: string;
+    description: string;
+    parameters: string | Record<string, unknown>;
+    exitId?: string;
+}
+interface AgentServiceConfig {
+    provider: string;
+    model: string;
+    api_key?: string;
+    options?: Record<string, unknown>;
+}
+interface INPUT {
+    system_instruction_mode: SystemInstructionMode;
+    system_instruction: string;
+    developer_messages_mode: 'append' | 'replace';
+    developer_messages: Array<string | {
+        message?: string;
+    }>;
+    tools_mode: 'append' | 'replace';
+    tools: Tool[];
+    custom_config_enabled: boolean;
+    mode: string;
+    stt: Partial<AgentServiceConfig>;
+    llm: Partial<AgentServiceConfig>;
+    tts: Partial<AgentServiceConfig>;
+    realtime: Partial<AgentServiceConfig>;
+}
+export default class UpdateVoiceAgent extends VoiceStep<Partial<INPUT>> {
+    runStep(): Promise<void>;
+    exitToThread(): Promise<void>;
+    private findExitByLabel;
+    private normalizeMessages;
+    private buildTools;
+    private buildOptionalServiceOverride;
+    private parseAgentServiceOptions;
+    private isStepFlagEnabled;
+}
+export {};

package/dst/Update Voice Agent.js

@@ -0,0 +1,183 @@
+"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 UpdateVoiceAgent extends voice_1.default {
+    async runStep() {
+        const call = await this.fetchData();
+        this.triggers.local(`in/voice/${call.id}`, async (event) => {
+            switch (event.params.type) {
+                case 'ok': {
+                    const hasTools = (this.data.tools || []).some(t => t && !lodash_1.default.isEmpty(lodash_1.default.trim(t.name)));
+                    if (hasTools) {
+                        return;
+                    }
+                    return this.exitStep('next');
+                }
+                case 'function_call': {
+                    const cb = this.thread.takeCallback();
+                    const name = event.params.name ?? 'function_call';
+                    const params = event.params.arguments ?? {};
+                    const functionId = event.params.functionId ?? '';
+                    const exitId = this.findExitByLabel(name);
+                    if (exitId) {
+                        this.exitStep(exitId, {
+                            [name]: params,
+                            name,
+                            functionId,
+                            __voicecb: cb,
+                            callId: call.id,
+                            callType: call.type,
+                            callCallback: call.callback,
+                        }, true);
+                    }
+                    else {
+                        this.log.warn('Update Voice Agent: no exit for function_call', { name });
+                    }
+                    return;
+                }
+                case 'hangup':
+                    await this.handleHangup(call);
+                    return await this.waitConvEnd();
+                case 'error':
+                    return this.throwError(event.params.error);
+                case 'cancel':
+                    return this.end();
+            }
+        });
+        this.triggers.otherwise(async () => {
+            const { system_instruction_mode = 'append', system_instruction = '', developer_messages_mode = 'append', developer_messages = [], tools_mode = 'append', tools: toolDefs = [], custom_config_enabled = false, mode = '', stt = {}, llm = {}, tts = {}, realtime = {}, } = this.data;
+            const params = {};
+            if (system_instruction_mode !== 'off'
+                && !lodash_1.default.isEmpty(lodash_1.default.trim(String(system_instruction)))) {
+                params.system_instruction = {
+                    mode: system_instruction_mode === 'replace' ? 'replace' : 'append',
+                    text: String(system_instruction),
+                };
+            }
+            const resolvedRulesMode = developer_messages_mode === 'replace' ? 'replace' : 'append';
+            const rules = this.normalizeMessages(developer_messages);
+            if (rules.length > 0 || resolvedRulesMode === 'replace') {
+                params.developer_messages = rules;
+                params.developer_messages_mode = resolvedRulesMode;
+            }
+            const resolvedToolsMode = tools_mode === 'replace' ? 'replace' : 'append';
+            const tools = this.buildTools(toolDefs);
+            if (tools.length > 0 || resolvedToolsMode === 'replace') {
+                params.tools = tools;
+                params.tools_mode = resolvedToolsMode;
+            }
+            if (this.isStepFlagEnabled(custom_config_enabled)) {
+                if (mode !== 'waterfall' && mode !== 'realtime') {
+                    this.throwError(new Error(`Update Voice Agent: unknown mode "${mode}"`));
+                }
+                params.mode = mode;
+                if (mode === 'realtime') {
+                    const realtimeOverride = this.buildOptionalServiceOverride('realtime', realtime);
+                    if (!realtimeOverride) {
+                        this.throwError(new Error('Update Voice Agent: set realtime model or options when pipeline override is enabled'));
+                    }
+                    params.realtime = realtimeOverride;
+                }
+                else {
+                    const sttOverride = this.buildOptionalServiceOverride('stt', stt);
+                    const llmOverride = this.buildOptionalServiceOverride('llm', llm);
+                    const ttsOverride = this.buildOptionalServiceOverride('tts', tts);
+                    if (!sttOverride && !llmOverride && !ttsOverride) {
+                        this.throwError(new Error('Update Voice Agent: set at least one model or options when pipeline override is enabled'));
+                    }
+                    if (sttOverride)
+                        params.stt = sttOverride;
+                    if (llmOverride)
+                        params.llm = llmOverride;
+                    if (ttsOverride)
+                        params.tts = ttsOverride;
+                }
+            }
+            if (!params.system_instruction
+                && params.developer_messages == null
+                && params.tools == null
+                && !params.mode) {
+                this.throwError(new Error('Update Voice Agent: provide a system instruction update, at least one rule, at least one tool, or a pipeline/models override'));
+            }
+            await this.sendCommands(call, [{ name: 'updateAgent', params }]);
+            return this.exitFlow();
+        });
+    }
+    async exitToThread() {
+        const result = this.state.result;
+        await this.thread.set(`__voiceAgentContext_${this.thread.id}`, result);
+        this.thread.exitStep(this.state.exitStep, result);
+    }
+    findExitByLabel(label) {
+        const exit = lodash_1.default.find(this.step.exits, (e) => e.label === label);
+        return exit?.id;
+    }
+    normalizeMessages(messages) {
+        return (messages || [])
+            .map(item => typeof item === 'string' ? item : item?.message ?? '')
+            .map(msg => lodash_1.default.trim(String(msg)))
+            .filter(msg => !lodash_1.default.isEmpty(msg));
+    }
+    buildTools(tools) {
+        return (tools || [])
+            .filter(t => t && !lodash_1.default.isEmpty(lodash_1.default.trim(t.name)))
+            .map(t => {
+            let parameters = {};
+            if (typeof t.parameters === 'string') {
+                try {
+                    parameters = JSON.parse(t.parameters) || {};
+                }
+                catch {
+                    parameters = {};
+                }
+            }
+            else if (t.parameters && typeof t.parameters === 'object') {
+                parameters = t.parameters;
+            }
+            return {
+                type: 'function',
+                name: lodash_1.default.trim(t.name),
+                description: t.description || '',
+                parameters,
+            };
+        });
+    }
+    buildOptionalServiceOverride(label, service) {
+        const options = this.parseAgentServiceOptions(label, service.options);
+        const hasModel = !lodash_1.default.isEmpty(lodash_1.default.trim(String(service.model ?? '')));
+        const hasOptions = options != null && Object.keys(options).length > 0;
+        if (!hasModel && !hasOptions) {
+            return undefined;
+        }
+        if (lodash_1.default.isEmpty(service.provider)) {
+            this.throwError(new Error(`Update Voice Agent: provider is required for ${label} (locked from Voice Agent pipeline)`));
+        }
+        return {
+            provider: service.provider ?? '',
+            model: hasModel ? lodash_1.default.trim(String(service.model)) : '',
+            options,
+        };
+    }
+    parseAgentServiceOptions(label, options) {
+        if (options == null || options === '')
+            return undefined;
+        if (typeof options === 'string') {
+            try {
+                options = JSON.parse(options);
+            }
+            catch {
+                this.throwError(new Error(`Update Voice Agent: invalid options JSON for ${label}`));
+            }
+        }
+        if (typeof options !== 'object' || Array.isArray(options)) {
+            this.throwError(new Error(`Update Voice Agent: options for ${label} must be a JSON object`));
+        }
+        return options;
+    }
+    isStepFlagEnabled(value) {
+        return value === true || value === 'true' || value === 1 || value === '1';
+    }
+}
+exports.default = UpdateVoiceAgent;

package/dst/{Voice Agent Function Result.d.ts → Voice Agent Tool Result.d.ts }

@@ -3,7 +3,7 @@ interface INPUT {
     result: string;
     stopAgent: boolean;
 }
-export default class VoiceAgentFunctionResult extends VoiceStep<INPUT> {
+export default class VoiceAgentToolResult extends VoiceStep<INPUT> {
     runStep(): Promise<void>;
 }
 export {};

package/dst/{Voice Agent Function Result.js → Voice Agent Tool Result.js }

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
-class VoiceAgentFunctionResult extends voice_1.default {
+class VoiceAgentToolResult extends voice_1.default {
     async runStep() {
         const { result, stopAgent } = this.data;
         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)');
+            throw new Error('Voice Agent Tool Result: missing call context (must be placed on a Voice Agent tool exit)');
         }
-        const { callId, callCallback, name: functionName, functionId } = ctx;
-        this.log.info("Voice Agent Function Result", { functionId, callId, threadId: this.thread.id });
+        const { callId, callCallback, name: toolName, toolCallId } = ctx;
+        this.log.info('Voice Agent Tool Result', { toolCallId, callId, threadId: this.thread.id });
         const params = {
-            functionName,
-            functionId,
+            toolName,
+            toolCallId,
             result,
             options: { stop: stopAgent }
         };
@@ -22,7 +22,7 @@ class VoiceAgentFunctionResult extends voice_1.default {
             name: 'out/voice/voicer',
             params: {
                 id: callId,
-                commands: [{ name: 'agentFunctionResult', params }]
+                commands: [{ name: 'agentToolResult', params }]
             }
         }, {
             target: callCallback,
@@ -32,4 +32,4 @@ class VoiceAgentFunctionResult extends voice_1.default {
         this.exitStep('next');
     }
 }
-exports.default = VoiceAgentFunctionResult;
+exports.default = VoiceAgentToolResult;

package/dst/Voice Agent.js

@@ -8,19 +8,19 @@ class VoiceAgent extends voice_1.default {
         const call = await this.fetchData();
         this.triggers.local(`in/voice/${call.id}`, async (event) => {
             switch (event.params.type) {
-                case 'function_call': {
-                    if (event.params.type !== 'function_call')
+                case 'tool_call': {
+                    if (event.params.type !== 'tool_call')
                         return;
                     const cb = this.thread.takeCallback();
-                    const name = event.params.name ?? 'function_call';
+                    const name = event.params.name ?? 'tool_call';
                     const params = event.params.arguments ?? {};
-                    const functionId = event.params.functionId ?? '';
-                    const exitId = this.findExitByLabel(name) ?? this.getExitStepId('function_call');
+                    const toolCallId = event.params.toolCallId ?? '';
+                    const exitId = this.findExitByLabel(name) ?? this.getExitStepId('tool_call');
                     if (exitId) {
                         this.exitStep(exitId, {
                             [name]: params,
                             name,
-                            functionId,
+                            toolCallId,
                             __voicecb: cb,
                             callId: call.id,
                             callType: call.type,
@@ -28,7 +28,7 @@ class VoiceAgent extends voice_1.default {
                         }, true);
                     }
                     else {
-                        this.log.warn('no exit for function_call', { name });
+                        this.log.warn('no exit for tool_call', { name });
                     }
                     return;
                 }

package/package.json

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