@recombine-ai/platform 0.2.6-test.9 → 0.3.0

package/build/bosun/mock.js

@@ -0,0 +1,28 @@
+import { inspect } from 'node:util';
+export function createMock(logger, constructor, overrides) {
+    const mock = Object.create(constructor.prototype);
+    const properties = Object.getOwnPropertyDescriptors(constructor.prototype);
+    for (const [key, descriptor] of Object.entries(properties)) {
+        if (typeof descriptor.value === 'function' && key !== 'constructor') {
+            mock[key] = function (...args) {
+                let returnValue = {};
+                if (overrides && key in overrides && typeof overrides[key] === 'function') {
+                    returnValue = overrides[key](...args);
+                }
+                const logs = [`${constructor.name}.${key}\n\tCalled with:`, prettyArgs(args)];
+                if (returnValue) {
+                    logs.push(`\n\tReturning: ${prettyInspect(returnValue)}`);
+                }
+                logger.log(logs.join(' '));
+                return returnValue;
+            };
+        }
+    }
+    return mock;
+}
+function prettyArgs(args) {
+    return args.map((arg) => (typeof arg === 'object' ? prettyInspect(arg) : arg)).join(' ');
+}
+function prettyInspect(obj) {
+    return inspect(obj, { depth: null }).split('\n').join('\n\t');
+}

package/build/bosun/std-mocks/call-control.d.ts

@@ -0,0 +1,11 @@
+import { ICallControl } from '../../call-control';
+import { TestAgentFactoryProps } from '../interfaces/agent';
+interface CallControlCompatibleMock {
+    callControl: ICallControl;
+    waitForIdle: () => Promise<void>;
+    setReload: (_onReload: () => Promise<unknown>) => void;
+    setCallEnd: (_onReload: () => Promise<unknown>) => void;
+}
+export declare function createCallControlMock(props: TestAgentFactoryProps<object>): CallControlCompatibleMock;
+export {};
+//# sourceMappingURL=call-control.d.ts.map

package/build/bosun/std-mocks/call-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-control.d.ts","sourceRoot":"","sources":["../../../src/bosun/std-mocks/call-control.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAkB,MAAM,oBAAoB,CAAA;AAEjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,UAAU,yBAAyB;IAC/B,WAAW,EAAE,YAAY,CAAA;IACzB,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAChC,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IACtD,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;CAC1D;AAED,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,GACrC,yBAAyB,CAsH3B"}

package/build/bosun/std-mocks/call-control.js

@@ -0,0 +1,128 @@
+export function createCallControlMock(props) {
+    let onReload;
+    let onCallEnd;
+    let inFlight = 0;
+    let idleResolvers = [];
+    function trackReload() {
+        inFlight++;
+        setTimeout(() => {
+            onReload?.()
+                .catch((err) => {
+                props.logger.error('CallControl: reload failed', { err });
+            })
+                .finally(() => {
+                inFlight--;
+                if (inFlight === 0) {
+                    const resolvers = idleResolvers;
+                    idleResolvers = [];
+                    resolvers.forEach((r) => r());
+                }
+            });
+        });
+    }
+    function waitForIdle() {
+        if (inFlight === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => idleResolvers.push(resolve));
+    }
+    return {
+        callControl: {
+            async hangup(callId) {
+                await onCallEnd?.();
+                props.conversationalTracer?.addConversationalTrace({
+                    conversationId: callId,
+                    eventName: 'hangup-requested',
+                    role: 'agent',
+                    medium: 'phone',
+                    content: 'hangup',
+                    createdAt: Date.now(),
+                });
+                await props.conversationalTracer?.flush();
+            },
+            async transfer(_agentName, destination, callId) {
+                props.conversationalTracer?.addConversationalTrace({
+                    conversationId: callId,
+                    eventName: 'transfer-requested',
+                    role: 'agent',
+                    medium: 'phone',
+                    content: destination,
+                    createdAt: Date.now(),
+                });
+                await props.conversationalTracer?.flush();
+            },
+            async reload(_) {
+                props.logger.log('CallControl: reload');
+                await sleep(100);
+                trackReload();
+            },
+            async addMessage(_, message) {
+                await sleep(500);
+                await props.sendMessage(message);
+            },
+            async steer(_, payload) {
+                props.logger.log('CallControl: steer');
+                await sleep(500);
+                for (const message of payload.addMessages ?? []) {
+                    await props.sendMessage(message);
+                }
+                if (payload.respond) {
+                    trackReload();
+                }
+            },
+            async getCallDetails() {
+                props.logger.log('CallControl: getCallDetails');
+                return {
+                    callId: '',
+                    callDuration: 102,
+                    callEnd: '',
+                    callStart: '',
+                    endedReason: '',
+                    messages: props.getMessages(),
+                    error: null,
+                    recording: null,
+                    transcript: props
+                        .getMessages()
+                        .filter((m) => m.sender !== 'system')
+                        .map(mapToTranscript),
+                };
+            },
+            async setUpSip(...args) {
+                if (args.length) {
+                    props.logger.log('CallControl: setUpSip', { name: args[0], trunks: args[1] });
+                }
+                else {
+                    props.logger.log('CallControl: setUpSip');
+                }
+            },
+            async freeze() {
+                props.logger.log('CallControl: freeze');
+            },
+            async unfreeze() {
+                props.logger.log('CallControl: unfreeze');
+            },
+            async setVoiceSettings(_, settings) {
+                props.logger.log('CallControl: setVoiceSettings', { settings });
+            },
+        },
+        setReload(_onReload) {
+            onReload = _onReload;
+        },
+        setCallEnd(_onCallEnd) {
+            onCallEnd = _onCallEnd;
+        },
+        waitForIdle,
+    };
+}
+function sleep(t) {
+    if (process.env.IS_TEST === 'true')
+        return Promise.resolve();
+    return new Promise((r) => setTimeout(r, t));
+}
+function mapToTranscript(m) {
+    return {
+        text: m.text,
+        role: m.sender === 'agent' ? 'Agent' : 'User',
+        time: 'unknown',
+        duration: 0,
+    };
+}

package/build/bosun/std-mocks/platform.d.ts

@@ -0,0 +1,8 @@
+import { IModels, VoicePlatform } from '../../core';
+import { TestAgentFactoryProps, TestVoiceAgent } from '../interfaces/agent';
+export declare function getPlatformMocks<TContext extends {}, TModels extends IModels>(props: TestAgentFactoryProps<any>, models: TModels, basePath: string): Promise<{
+    platform: VoicePlatform<TContext, TModels>;
+    setLoopBack(this: void, bosunAgent: TestVoiceAgent): void;
+    waitForIdle: () => Promise<void>;
+}>;
+//# sourceMappingURL=platform.d.ts.map

package/build/bosun/std-mocks/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/bosun/std-mocks/platform.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAKnD,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAG3E,wBAAsB,gBAAgB,CAAC,QAAQ,SAAS,EAAE,EAAE,OAAO,SAAS,OAAO,EAC/E,KAAK,EAAE,qBAAqB,CAAC,GAAG,CAAC,EACjC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,MAAM;;sBAyCM,IAAI,cAAc,cAAc;;GAMzD"}

package/build/bosun/std-mocks/platform.js

@@ -0,0 +1,45 @@
+import { createInMemoryCache } from '../../context-cache';
+import { createAIEngine, createAIStreamEngine, createLocalFS } from '../../engine';
+import { createSlotBooker } from '../../steps';
+import { stubTelescope } from '../../telescope';
+import { TimeoutManager } from '../../timeout-manager';
+import { createCallControlMock } from './call-control';
+export async function getPlatformMocks(props, models, basePath) {
+    const streamAi = createAIStreamEngine({
+        logger: props.logger,
+        stepRegistry: props.stepRegistry,
+        stepTracer: props.stepTracer,
+    });
+    const ai = createAIEngine({
+        logger: props.logger,
+        stepRegistry: props.stepRegistry,
+        stepTracer: props.stepTracer,
+    });
+    const callControlMock = createCallControlMock(props);
+    const platform = {
+        streamAi,
+        ai,
+        fs: createLocalFS({
+            logger: props.logger,
+            basePath,
+        }),
+        logger: props.logger,
+        callControl: callControlMock.callControl,
+        timeoutManager: new TimeoutManager(createInMemoryCache(), props.logger, !props.config.enableTimers),
+        contextCache: createInMemoryCache(),
+        telescope: stubTelescope,
+        slotBooker: createSlotBooker({
+            specificInstructionsBasePath: basePath,
+            llmAdapter: Object.values(models.models)[0],
+        }),
+        ...models,
+    };
+    return {
+        platform,
+        setLoopBack(bosunAgent) {
+            callControlMock.setCallEnd(bosunAgent.onCallEnd);
+            callControlMock.setReload(bosunAgent.streamResponse);
+        },
+        waitForIdle: callControlMock.waitForIdle,
+    };
+}

package/build/bosun/test-agent.d.ts

@@ -0,0 +1,4 @@
+import { CallInfo, VoiceAgent } from '../agent';
+import { TestAgentFactoryProps, TestVoiceAgent } from './interfaces/agent';
+export declare function makeTestVoiceAgent(props: TestAgentFactoryProps<any>, agent: VoiceAgent<any>, waitForIdle: () => Promise<void>, testCall: CallInfo<any>): TestVoiceAgent;
+//# sourceMappingURL=test-agent.d.ts.map

package/build/bosun/test-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-agent.d.ts","sourceRoot":"","sources":["../../src/bosun/test-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAG1E,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,qBAAqB,CAAC,GAAG,CAAC,EACjC,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,EACtB,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAChC,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,GACxB,cAAc,CAmEhB"}

package/build/bosun/test-agent.js

@@ -0,0 +1,70 @@
+import { collectStream } from './utils';
+export function makeTestVoiceAgent(props, agent, waitForIdle, testCall) {
+    async function streamResponse() {
+        const messages = props.getMessages();
+        if (props.conversationalTracer) {
+            const lastMessage = messages.at(-1);
+            const lastText = lastMessage?.text ?? '';
+            const lastRole = lastMessage?.sender ?? 'user';
+            try {
+                props.conversationalTracer.addConversationalTrace({
+                    conversationId: testCall.callId,
+                    eventName: 'llm-handler-stream-requested',
+                    role: lastRole,
+                    medium: 'phone',
+                    content: lastText,
+                    createdAt: Date.now(),
+                });
+                await props.conversationalTracer.flush();
+            }
+            catch (err) {
+                props.logger.error('Failed to write conversational trace', { err });
+            }
+        }
+        const reply = await collectStream(await agent.streamResponse(messages, testCall));
+        await props.sendMessage(reply);
+        try {
+            props.conversationalTracer?.addConversationalTrace({
+                conversationId: testCall.callId,
+                eventName: 'finished-main-streaming-step',
+                role: 'agent',
+                medium: 'phone',
+                content: reply,
+                createdAt: Date.now(),
+            });
+            await props.conversationalTracer?.flush();
+        }
+        catch (err) {
+            props.logger.error('Failed to write conversational trace', { err });
+        }
+        await agent.onAgentSpeechDone(props.getMessages(), testCall);
+    }
+    return {
+        streamResponse: streamResponse,
+        onCallStart: async () => {
+            await agent.onCallStart(testCall);
+            await agent.onCallReady(testCall);
+        },
+        onCallEnd: async () => {
+            try {
+                props.conversationalTracer?.addConversationalTrace({
+                    conversationId: testCall.callId,
+                    eventName: 'hangup-requested',
+                    role: 'agent',
+                    medium: 'phone',
+                    content: 'hangup',
+                    createdAt: Date.now(),
+                });
+                await props.conversationalTracer?.flush();
+            }
+            catch (err) {
+                props.logger.error('Failed to write conversational trace', { err });
+            }
+            await agent.onCallEnd(testCall);
+        },
+        waitForIdle,
+        async onFatalError(error) {
+            props.logger.error(error);
+        },
+    };
+}

package/build/bosun/test-step-registry.d.ts

@@ -0,0 +1,14 @@
+import type { AIEngine, StepRegistry } from '../engine';
+export interface TestStepInput {
+    context: Record<string, unknown>;
+    stringifiedConversation: string;
+}
+export interface RegisteredTestStep {
+    name: string;
+    runForTest(input: TestStepInput): Promise<unknown>;
+}
+export interface TestStepRegistry extends StepRegistry {
+    addTestStep?(step: RegisteredTestStep): void;
+}
+export declare function registerTestableSteps<CTX extends object>(ai: AIEngine<CTX>, registry: TestStepRegistry): AIEngine<CTX>;
+//# sourceMappingURL=test-step-registry.d.ts.map

package/build/bosun/test-step-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-step-registry.d.ts","sourceRoot":"","sources":["../../src/bosun/test-step-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAe,YAAY,EAAgB,MAAM,WAAW,CAAA;AAElF,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,uBAAuB,EAAE,MAAM,CAAA;CAClC;AAED,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACrD;AAMD,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IAClD,WAAW,CAAC,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;CAC/C;AAeD,wBAAgB,qBAAqB,CAAC,GAAG,SAAS,MAAM,EACpD,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,EACjB,QAAQ,EAAE,gBAAgB,GAC3B,QAAQ,CAAC,GAAG,CAAC,CAqBf"}

package/build/bosun/test-step-registry.js

@@ -0,0 +1,48 @@
+export function registerTestableSteps(ai, registry) {
+    const addTestStep = registry.addTestStep?.bind(registry);
+    if (!addTestStep)
+        return ai;
+    const build = ai.getStepBuilder();
+    const testableBuilder = ((step) => {
+        const built = build(step);
+        if ('prompt' in built) {
+            addTestStep({
+                name: built.name,
+                runForTest: (input) => runIsolatedStep(ai, built, input),
+            });
+        }
+        return built;
+    });
+    return {
+        ...ai,
+        getStepBuilder: () => testableBuilder,
+    };
+}
+async function runIsolatedStep(ai, step, input) {
+    let output;
+    const isolatedStep = {
+        ...step,
+        runIf: undefined,
+        onError: undefined,
+        execute: async (response) => {
+            output = response;
+        },
+    };
+    const conversation = ai.createConversation();
+    Object.defineProperty(conversation, 'toString', {
+        configurable: true,
+        value: () => input.stringifiedConversation,
+    });
+    const workflow = ai.createWorkflow({
+        name: `bosun-test:${step.name}`,
+        steps: [isolatedStep],
+        onError: async (error) => {
+            throw new Error(error);
+        },
+    });
+    await workflow.run(conversation, () => input.context);
+    if (typeof output === 'undefined') {
+        throw new Error(`Step "${step.name}" completed without an output`);
+    }
+    return output;
+}

package/build/bosun/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function collectStream(stream: ReadableStream<{
+    delta: string;
+}>): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/build/bosun/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/bosun/utils.ts"],"names":[],"mappings":"AAAA,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,mBAM5E"}

package/build/bosun/utils.js

@@ -0,0 +1,7 @@
+export async function collectStream(stream) {
+    const result = [];
+    for await (const chunk of stream) {
+        result.push(chunk.delta);
+    }
+    return result.join('');
+}