@recombine-ai/platform 0.9.1-test.1 → 0.9.1-test.3

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

@@ -9,7 +9,7 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
     if (!predictiveModels) {
         throw new Error('Predictive models are not configured.');
     }
-    const { predictorModel, chooserModel } = predictiveModels;
+    const { predictorModel, chooser } = predictiveModels;
     if (!Number.isInteger(config.predictionCount) || config.predictionCount < 1) {
         throw new Error('predictionCount must be a positive integer.');
     }
@@ -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;
@@ -81,28 +96,55 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
             throw createOperationError(error, config.model, mainTrace);
         });
         const firstProvisionalChunk = readFirstNonEmptyChunk(provisionalStream, mainTrace, config.model);
-        const chooserResults = predictions.map((pair) => choosePrediction(pair, messages, ctx, runId, isCurrent));
+        const chooserResult = predictions.length
+            ? choosePrediction(predictions, messages, ctx, runId, isCurrent)
+            : new Promise(() => undefined);
         function isCurrent() {
             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 });
@@ -116,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);
             }
@@ -124,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();
@@ -163,27 +219,27 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         }
         async function orchestrate(controller) {
             try {
-                const winner = await Promise.race([firstProvisionalChunk, ...chooserResults]);
+                const winner = await Promise.race([firstProvisionalChunk, chooserResult]);
                 if (!isCurrent())
                     return;
                 if (winner.kind === 'prediction') {
                     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) {
@@ -210,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 || {});
@@ -229,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);
@@ -267,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()}`,
@@ -281,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;
@@ -364,46 +483,81 @@ export function createPredictiveWorkflow(config, engineConfig, nunjucksEnv) {
         });
         return { pairs, trace };
     }
-    async function choosePrediction(pair, messages, ctx, parentRunId, isActive) {
+    async function choosePrediction(pairs, messages, ctx, parentRunId, isActive) {
+        const callId = getCallId(ctx);
+        const chooserStartedAt = Date.now();
         const actualUserResponse = messages.at(-1)?.text ?? '';
-        const history = stringifyMessages(messages.slice(0, -1));
-        const rendered = nunjucksEnv.renderString(chooserPrompt, {
-            history,
-            reference: pair.userResponse,
-            alternative: actualUserResponse,
-        });
+        const history = messages.slice(0, -1);
+        const stringifiedHistory = stringifyMessages(history);
+        const input = { history, actualUserResponse, candidates: pairs };
         const trace = {
             workflowId: config.name,
             workflowRunId: parentRunId,
             name: 'chooser',
-            model: JSON.stringify(chooserModel.getOptions()),
+            model: JSON.stringify(chooser.getOptions()),
             createdAt: Date.now(),
             response: '',
             receivedContext: ctx,
             receivedPrompt: chooserPrompt,
-            renderedPrompt: rendered,
-            stringifiedConversation: history,
+            renderedPrompt: JSON.stringify(input),
+            stringifiedConversation: stringifiedHistory,
         };
-        let raw;
+        let result;
         try {
-            raw = await chooserModel.generateResponse('', rendered);
+            result = await chooser.choose(input);
         }
         catch (error) {
-            throw createOperationError(error, chooserModel, trace);
+            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);
-        const label = raw.trim();
-        trace.response = label;
-        if (label !== 'N' && label !== 'U') {
-            if (label === 'E') {
-                void addAndFlushTrace(stepTracer, trace, logger);
-                return { kind: 'prediction', pair };
-            }
-            throw createOperationError(new Error(`Chooser returned an invalid label: ${label}`), chooserModel, trace);
         }
+        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);
+        }
+        if (!Number.isInteger(result.selectedIndex) ||
+            result.selectedIndex < 0 ||
+            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 new Promise(() => undefined);
+        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.1",
+  "version": "0.9.1-test.3",
   "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",
@@ -42,6 +42,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
+    "@typesafe-ai/sdk": "0.6.0",
     "dotenv": "17.4.2",
     "esbuild": "0.27.3",
     "fast-xml-parser": "5.7.3",

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

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