@recombine-ai/platform 0.9.1-test.2 → 0.9.1-test.4

package/build/call-control/schemas.generated.d.ts

@@ -123,6 +123,8 @@ export declare const configSchema: z.ZodObject<{
         eleven_flash_v2: "eleven_flash_v2";
         eleven_v3: "eleven_v3";
         eleven_v3_conversational: "eleven_v3_conversational";
+        eleven_v4: "eleven_v4";
+        eleven_v4_turbo: "eleven_v4_turbo";
     }>>;
     tts_text_prefix: z.ZodDefault<z.ZodString>;
     tts_inactivity_timeout: z.ZodDefault<z.ZodNumber>;

package/build/call-control/schemas.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.generated.d.ts","sourceRoot":"","sources":["../../src/call-control/schemas.generated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwTvB,CAAA"}
+{"version":3,"file":"schemas.generated.d.ts","sourceRoot":"","sources":["../../src/call-control/schemas.generated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0TvB,CAAA"}

package/build/call-control/schemas.generated.js

@@ -228,6 +228,8 @@ export const configSchema = z.object({
         'eleven_flash_v2',
         'eleven_v3',
         'eleven_v3_conversational',
+        'eleven_v4',
+        'eleven_v4_turbo',
     ])
         .describe('ElevenLabs model to use')
         .default('eleven_turbo_v2'),

package/build/call-control/voice-agent-config.d.ts

@@ -122,6 +122,8 @@ export declare const voiceAgentConfigSchema: import("zod").ZodObject<{
         eleven_flash_v2: "eleven_flash_v2";
         eleven_v3: "eleven_v3";
         eleven_v3_conversational: "eleven_v3_conversational";
+        eleven_v4: "eleven_v4";
+        eleven_v4_turbo: "eleven_v4_turbo";
     }>>;
     tts_text_prefix: import("zod").ZodDefault<import("zod").ZodString>;
     tts_inactivity_timeout: import("zod").ZodDefault<import("zod").ZodNumber>;

package/build/call-control/voice-agent-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"voice-agent-config.d.ts","sourceRoot":"","sources":["../../src/call-control/voice-agent-config.ts"],"names":[],"mappings":"AAyDA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGjC,CAAA;AAEF,wBAAgB,uCAAuC,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAK/E"}
+{"version":3,"file":"voice-agent-config.d.ts","sourceRoot":"","sources":["../../src/call-control/voice-agent-config.ts"],"names":[],"mappings":"AAyDA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGjC,CAAA;AAEF,wBAAgB,uCAAuC,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAK/E"}

package/build/engine/interfaces/stream.d.ts

@@ -39,9 +39,16 @@ export interface PredictionChooserResult {
         inputTokens: number;
         outputTokens: number;
     };
+    diagnostics?: {
+        requestDurationMs: number;
+        upstreamDurationMs?: number;
+        requestId?: string;
+        retryCount: number;
+    };
 }
 export interface PredictionChooser {
     choose: (input: PredictionChooserInput) => Promise<PredictionChooserResult>;
+    prewarm?: () => Promise<void>;
     getOptions: () => unknown;
     getProviderInfo?: () => LlmProviderInfo;
 }

package/build/engine/interfaces/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/engine/interfaces/stream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/engine/interfaces/stream.ts"],"names":[],"mappings":"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"}

package/build/engine/stream/jev-prediction-chooser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jev-prediction-chooser.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/jev-prediction-chooser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAA2C,MAAM,kBAAkB,CAAA;AAEtF,OAAO,KAAK,EAAE,iBAAiB,EAA2B,MAAM,wBAAwB,CAAA;AAGxF,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IAEjB,KAAK,CAAC,EAAE,KAAK,CAAA;CAChB;AAED,wBAAgB,0BAA0B,CACtC,OAAO,EAAE,2BAA2B,GACrC,iBAAiB,CAgEnB"}
+{"version":3,"file":"jev-prediction-chooser.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/jev-prediction-chooser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAA2C,MAAM,kBAAkB,CAAA;AAEtF,OAAO,KAAK,EAAE,iBAAiB,EAA2B,MAAM,wBAAwB,CAAA;AAGxF,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IAEjB,KAAK,CAAC,EAAE,KAAK,CAAA;CAChB;AAED,wBAAgB,0BAA0B,CACtC,OAAO,EAAE,2BAA2B,GACrC,iBAAiB,CA6EnB"}

package/build/engine/stream/jev-prediction-chooser.js

@@ -2,13 +2,7 @@ import { TypeSafeClient, noul } from '@typesafe-ai/sdk';
 import { chooserPrompt } from './predictive-prompts.js';
 export function createJevPredictionChooser(options) {
     validateOptions(options);
-    const client = new TypeSafeClient({
-        apiKey: options.apiKey,
-        defaultModel: options.model,
-        fetch: options.fetch,
-        logLevel: 'off',
-        timeout: options.timeoutMs,
-    });
+    const transport = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
     return {
         getOptions: () => ({
             model: options.model,
@@ -16,14 +10,24 @@ export function createJevPredictionChooser(options) {
             timeoutMs: options.timeoutMs,
         }),
         getProviderInfo: () => ({ provider: 'typesafe', model: options.model }),
+        async prewarm() {
+            await Promise.all([prewarm(transport, options), prewarm(transport, options)]);
+        },
         async choose(input) {
             if (input.candidates.length === 0) {
                 throw new Error('Jev prediction chooser requires at least one candidate.');
             }
+            let attemptCount = 0;
+            const client = createClient(options, async (request, init) => {
+                attemptCount += 1;
+                return transport(request, init);
+            });
             const questions = createQuestions(input.candidates.length);
-            const result = await client.systemOne({
+            const startedAt = Date.now();
+            const request = client.systemOne({
                 model: options.model,
                 state: {
+                    reply_safety_policy: chooserPrompt,
                     conversation_history: input.history.map((message) => ({
                         role: message.sender,
                         text: message.text,
@@ -36,6 +40,7 @@ export function createJevPredictionChooser(options) {
                 },
                 questions,
             });
+            const { data: result, response, requestId } = await request.withResponse();
             const scores = input.candidates.map((_, index) => {
                 const answer = result.answers[questionId(index)];
                 if (!answer ||
@@ -56,6 +61,12 @@ export function createJevPredictionChooser(options) {
                     inputTokens: result.usage.input_tokens,
                     outputTokens: result.usage.output_tokens,
                 },
+                diagnostics: {
+                    requestDurationMs: Date.now() - startedAt,
+                    upstreamDurationMs: parseDurationHeader(response.headers.get('x-envoy-upstream-service-time')),
+                    requestId,
+                    retryCount: Math.max(0, attemptCount - 1),
+                },
             };
         },
     };
@@ -63,12 +74,35 @@ export function createJevPredictionChooser(options) {
 function createQuestions(candidateCount) {
     return Object.fromEntries(Array.from({ length: candidateCount }, (_, index) => [
         questionId(index),
-        noul(`${chooserPrompt}\n\nEvaluate \`candidates[${index}]\` against \`actual_user_response\` and \`conversation_history\`.`, {
-            true: 'The prepared agent response meets every safety and relevance condition.',
-            false: 'The prepared agent response violates one or more safety or relevance conditions.',
+        noul(`Is \`candidates[${index}].prepared_agent_response\` safe and natural immediately after \`actual_user_response\`? The predicted user response only explains where the prepared response came from. It does not replace the actual response. Apply every rule in \`reply_safety_policy\`.`, {
+            true: 'Every requirement in reply_safety_policy is met.',
+            false: 'At least one requirement in reply_safety_policy is not met.',
         }),
     ]));
 }
+function createClient(options, fetch) {
+    return new TypeSafeClient({
+        apiKey: options.apiKey,
+        defaultModel: options.model,
+        fetch,
+        logLevel: 'off',
+        timeout: options.timeoutMs,
+    });
+}
+async function prewarm(transport, options) {
+    const client = createClient(options, transport);
+    await client.systemOne({
+        model: options.model,
+        state: 'Hello.',
+        questions: { greeting: noul('Is this a greeting?') },
+    });
+}
+function parseDurationHeader(value) {
+    if (value === null)
+        return undefined;
+    const duration = Number(value);
+    return Number.isFinite(duration) && duration >= 0 ? duration : undefined;
+}
 function selectCandidate(scores, threshold) {
     let selectedIndex;
     let selectedScore = threshold;

package/build/engine/stream/predictive-workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predictive-workflow.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/predictive-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAM/B,OAAO,KAAK,EAOR,2BAA2B,EAC3B,wBAAwB,EAExB,qBAAqB,EAExB,MAAM,wBAAwB,CAAA;AAgD/B,wBAAgB,wBAAwB,CAAC,GAAG,SAAS,MAAM,EACvD,MAAM,EAAE,wBAAwB,CAAC,GAAG,CAAC,EACrC,YAAY,EAAE,qBAAqB,EACnC,WAAW,EAAE,QAAQ,CAAC,WAAW,GAClC,2BAA2B,CAAC,GAAG,CAAC,CAoclC"}
+{"version":3,"file":"predictive-workflow.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/predictive-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAM/B,OAAO,KAAK,EAOR,2BAA2B,EAC3B,wBAAwB,EAExB,qBAAqB,EAExB,MAAM,wBAAwB,CAAA;AAkD/B,wBAAgB,wBAAwB,CAAC,GAAG,SAAS,MAAM,EACvD,MAAM,EAAE,wBAAwB,CAAC,GAAG,CAAC,EACrC,YAAY,EAAE,qBAAqB,EACnC,WAAW,EAAE,QAAQ,CAAC,WAAW,GAClC,2BAA2B,CAAC,GAAG,CAAC,CAumBlC"}

package/build/engine/stream/predictive-workflow.js

@@ -48,8 +48,10 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         state.stopCurrent?.();
         state.requestGeneration += 1;
         const generation = state.requestGeneration;
-        const isUserTurn = messages.at(-1)?.sender === 'user';
-        const predictionSets = isUserTurn
+        const lastMessage = messages.at(-1);
+        const isUserTurn = lastMessage?.sender === 'user';
+        const isSubstantiveUserTurn = isUserTurn && lastMessage.text.trim().length > 0;
+        const predictionSets = isSubstantiveUserTurn
             ? [state.preparedPrewarm, state.preparedNormal].filter(isPreparedSet)
             : [];
         const predictions = predictionSets.flatMap((set) => set.pairs);
@@ -57,6 +59,7 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         const renderedPrompt = nunjucksEnv.renderString(template, ctx || {});
         const stringifiedConversation = stringifyMessages(messages);
         const runId = crypto.randomUUID();
+        const responseStartedAt = Date.now();
         const mainTrace = {
             workflowId: config.name,
             workflowRunId: runId,
@@ -69,6 +72,18 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             renderedPrompt,
             stringifiedConversation,
         };
+        logger.info('Predictive response started', {
+            callId,
+            runId,
+            generation,
+            messageCount: messages.length,
+            lastMessageSender: lastMessage?.sender,
+            lastMessageLength: lastMessage?.text.length ?? 0,
+            isSubstantiveUserTurn,
+            prewarmPredictionCount: state.preparedPrewarm?.pairs.length ?? 0,
+            normalPredictionCount: state.preparedNormal?.pairs.length ?? 0,
+            chooserCandidateCount: predictions.length,
+        });
         let active = true;
         let output = '';
         let outputStarted = false;
@@ -88,23 +103,48 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             return active && !state.closed && state.requestGeneration === generation;
         }
         function consumePredictions() {
+            const consumesPrewarm = isSubstantiveUserTurn && !state.prewarmConsumed;
+            const consumedPrewarmCount = consumesPrewarm
+                ? (state.preparedPrewarm?.pairs.length ?? 0)
+                : 0;
+            let consumedNormalCount = 0;
             for (const set of predictionSets) {
-                if (state.preparedPrewarm?.id === set.id) {
-                    state.preparedPrewarm = undefined;
-                    state.prewarmConsumed = true;
-                }
                 if (state.preparedNormal?.id === set.id) {
+                    consumedNormalCount = set.pairs.length;
                     state.preparedNormal = undefined;
                 }
             }
+            if (consumesPrewarm) {
+                state.preparedPrewarm = undefined;
+                state.prewarmConsumed = true;
+            }
+            if (isSubstantiveUserTurn || consumedNormalCount > 0) {
+                logger.info('Prepared predictions consumed', {
+                    callId,
+                    runId,
+                    generation,
+                    prewarmPredictionCount: consumedPrewarmCount,
+                    normalPredictionCount: consumedNormalCount,
+                });
+            }
         }
-        function publish(controller, delta) {
+        function publish(controller, delta, source, match) {
             if (!isCurrent() || !delta)
                 return false;
             if (!outputStarted) {
                 outputStarted = true;
                 consumePredictions();
                 logger.debug(`[MARK] Predictive workflow TTFT: ${config.name}`);
+                logger.info('Predictive response winner selected', {
+                    callId,
+                    runId,
+                    generation,
+                    source,
+                    ttftMs: Date.now() - responseStartedAt,
+                    chooserCandidateCount: predictions.length,
+                    selectedIndex: match?.index,
+                    selectedScore: match?.score,
+                });
             }
             output += delta;
             controller.enqueue({ role: 'agent', delta });
@@ -118,6 +158,13 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
                 state.stopCurrent = undefined;
             mainTrace.response = output;
             void addAndFlushTrace(stepTracer, mainTrace, logger);
+            logger.info('Predictive response completed', {
+                callId,
+                runId,
+                generation,
+                durationMs: Date.now() - responseStartedAt,
+                outputLength: output.length,
+            });
             if (!state.closed) {
                 startNormalPrediction(messages, output, renderedPrompt, ctx, state, generation);
             }
@@ -126,6 +173,13 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             if (!active)
                 return;
             active = false;
+            logger.info('Predictive response stopped', {
+                callId,
+                runId,
+                generation,
+                outputStarted,
+                durationMs: Date.now() - responseStartedAt,
+            });
             void provisionalReader?.cancel();
             try {
                 publicController?.close();
@@ -172,20 +226,20 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
                     void firstProvisionalChunk
                         .then(({ reader }) => reader.cancel())
                         .catch(() => undefined);
-                    publish(controller, winner.pair.agentResponse);
+                    publish(controller, winner.pair.agentResponse, winner.kind, winner);
                     controller.close();
                     finishSuccessfulResponse();
                     return;
                 }
                 provisionalReader = winner.reader;
-                if (!publish(controller, winner.chunk))
+                if (!publish(controller, winner.chunk, winner.kind))
                     return;
                 while (isCurrent()) {
                     try {
                         const next = await winner.reader.read();
                         if (next.done)
                             break;
-                        if (!publish(controller, next.value))
+                        if (!publish(controller, next.value, winner.kind))
                             return;
                     }
                     catch (error) {
@@ -212,14 +266,42 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         });
     }
     function prewarmForUsersHello(ctx) {
-        if (config.prewarmPredictions.length === 0)
-            return;
         const callId = getCallId(ctx);
         const state = getOrCreateState(callId);
-        if (state.prewarmStarted || state.prewarmConsumed)
+        if (state.prewarmStarted || state.prewarmConsumed) {
+            logger.debug('Opening prediction prewarm skipped', {
+                callId,
+                prewarmStarted: state.prewarmStarted,
+                prewarmConsumed: state.prewarmConsumed,
+            });
             return;
+        }
         state.prewarmStarted = true;
+        logger.info('Opening prediction prewarm started', {
+            callId,
+            predictionCount: config.prewarmPredictions.length,
+            chooserPrewarmEnabled: chooser.prewarm !== undefined,
+        });
+        const chooserPrewarmStartedAt = Date.now();
+        void chooser
+            .prewarm?.()
+            .then(() => {
+            logger.info('Prediction chooser prewarm completed', {
+                callId,
+                durationMs: Date.now() - chooserPrewarmStartedAt,
+            });
+        })
+            .catch((error) => {
+            logger.warn('Prediction chooser prewarm failed', {
+                callId,
+                durationMs: Date.now() - chooserPrewarmStartedAt,
+                error,
+            });
+        });
+        if (config.prewarmPredictions.length === 0)
+            return;
         const generation = state.requestGeneration;
+        const predictionStartedAt = Date.now();
         const task = (async () => {
             const template = typeof config.prompt === 'string' ? config.prompt : await config.prompt.content();
             const renderedPrompt = nunjucksEnv.renderString(template, ctx || {});
@@ -231,18 +313,32 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
                 supplementalPredictions: config.prewarmPredictions,
                 traceName: 'predictor[prewarm]',
             });
-            if (!state.closed && !state.prewarmConsumed && state.requestGeneration === generation) {
+            const stored = !state.closed && !state.prewarmConsumed;
+            if (stored) {
                 state.preparedPrewarm = { id: crypto.randomUUID(), pairs: prediction.pairs };
+            }
+            logger.info('Opening prediction prewarm completed', {
+                callId,
+                durationMs: Date.now() - predictionStartedAt,
+                predictionCount: prediction.pairs.length,
+                stored,
+                discardReason: state.closed
+                    ? 'call-closed'
+                    : state.prewarmConsumed
+                        ? 'opening-turn-consumed'
+                        : undefined,
+            });
+            if (!state.closed) {
                 await addAndFlushTrace(stepTracer, prediction.trace, logger);
             }
         })();
-        trackPrediction(task, state, ctx, generation);
+        trackPrediction(task, state, ctx, generation, () => !state.prewarmConsumed);
     }
     async function waitForPendingPrediction(callId) {
         const state = states.get(callId);
         if (!state)
             return;
-        await Promise.all([...(state.pendingPredictions.get(state.requestGeneration) ?? [])]);
+        await Promise.all([...state.pendingPredictions.values()].flatMap((predictions) => [...predictions]));
     }
     function clear(callId) {
         const state = states.get(callId);
@@ -269,6 +365,12 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         return state;
     }
     function startNormalPrediction(messages, agentResponse, renderedMainPrompt, ctx, state, generation) {
+        const callId = getCallId(ctx);
+        const predictionStartedAt = Date.now();
+        logger.debug('Normal prediction generation started', {
+            callId,
+            generation,
+        });
         const conversationWithResponse = [
             stringifyMessages(messages).trim(),
             `Agent: ${agentResponse.trim()}`,
@@ -283,16 +385,31 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             supplementalPredictions: config.normalFlowPredictions,
             traceName: 'predictor[normal]',
         }).then(async (prediction) => {
-            if (!state.closed && state.requestGeneration === generation) {
+            const stored = !state.closed && state.requestGeneration === generation;
+            if (stored) {
                 state.preparedNormal = { id: crypto.randomUUID(), pairs: prediction.pairs };
+            }
+            logger.info('Normal prediction generation completed', {
+                callId,
+                generation,
+                durationMs: Date.now() - predictionStartedAt,
+                predictionCount: prediction.pairs.length,
+                stored,
+                discardReason: state.closed
+                    ? 'call-closed'
+                    : state.requestGeneration !== generation
+                        ? 'conversation-changed'
+                        : undefined,
+            });
+            if (!state.closed) {
                 await addAndFlushTrace(stepTracer, prediction.trace, logger);
             }
         });
         trackPrediction(task, state, ctx, generation);
     }
-    function trackPrediction(task, state, ctx, generation) {
+    function trackPrediction(task, state, ctx, generation, isRelevant = () => state.requestGeneration === generation) {
         const handled = task.catch(async (error) => {
-            if (state.closed || state.requestGeneration !== generation)
+            if (state.closed || !isRelevant())
                 return;
             const operation = isOperationError(error) ? error : undefined;
             const cause = operation?.cause ?? error;
@@ -367,6 +484,8 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         return { pairs, trace };
     }
     async function choosePrediction(pairs, messages, ctx, parentRunId, isActive) {
+        const callId = getCallId(ctx);
+        const chooserStartedAt = Date.now();
         const actualUserResponse = messages.at(-1)?.text ?? '';
         const history = messages.slice(0, -1);
         const stringifiedHistory = stringifyMessages(history);
@@ -390,13 +509,29 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         catch (error) {
             throw createOperationError(error, chooser, trace);
         }
-        if (!isActive())
+        if (!isActive()) {
+            logger.debug('Prediction chooser result ignored', {
+                callId,
+                parentRunId,
+                durationMs: Date.now() - chooserStartedAt,
+                reason: 'response-replaced',
+            });
             return new Promise(() => undefined);
+        }
         trace.response = JSON.stringify(result);
         if (result.scores.length !== pairs.length) {
             throw createOperationError(new Error('Chooser returned the wrong number of candidate scores.'), chooser, trace);
         }
         if (result.selectedIndex === undefined) {
+            logger.info('Prediction chooser completed', {
+                callId,
+                parentRunId,
+                durationMs: Date.now() - chooserStartedAt,
+                candidateCount: pairs.length,
+                scores: result.scores,
+                usage: result.usage,
+                diagnostics: result.diagnostics,
+            });
             void addAndFlushTrace(stepTracer, trace, logger);
             return new Promise(() => undefined);
         }
@@ -405,8 +540,24 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             result.selectedIndex >= pairs.length) {
             throw createOperationError(new Error('Chooser returned an invalid candidate index.'), chooser, trace);
         }
+        logger.info('Prediction chooser completed', {
+            callId,
+            parentRunId,
+            durationMs: Date.now() - chooserStartedAt,
+            candidateCount: pairs.length,
+            selectedIndex: result.selectedIndex,
+            selectedScore: result.scores[result.selectedIndex],
+            scores: result.scores,
+            usage: result.usage,
+            diagnostics: result.diagnostics,
+        });
         void addAndFlushTrace(stepTracer, trace, logger);
-        return { kind: 'prediction', pair: pairs[result.selectedIndex] };
+        return {
+            kind: 'prediction',
+            pair: pairs[result.selectedIndex],
+            index: result.selectedIndex,
+            score: result.scores[result.selectedIndex],
+        };
     }
     return { run, prewarmForUsersHello, waitForPendingPrediction, clear };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@recombine-ai/platform",
   "type": "module",
-  "version": "0.9.1-test.2",
+  "version": "0.9.1-test.4",
   "description": "The Recombine platform: engine, telescope, dockyard, call control, the voice agent API, and the Bosun bindings in one package",
   "license": "EULA",
   "author": "recombine.ai",

package/build/bosun-app/frontend/client/_app/immutable/chunks/COI2cH3y.js.br

@@ -1,3 +0,0 @@
-1
@deN?��) x<�Dn��َ!�2��/vQ���A�B�]5V�|Zȓp
-��
-3����W4�io<����أ��1^4�������3O@�w�"mH�o�

package/build/bosun-app/frontend/client/_app/immutable/entry/start.BNSaABB8.js

@@ -1 +0,0 @@
-import{a as r}from"../chunks/B3sRmUmR.js";import{y as t}from"../chunks/YRWW-SW8.js";export{t as load_css,r as start};