@kuralle-agents/core 0.3.2 → 0.3.3

package/dist/flow/collectUntilComplete.js

@@ -19,6 +19,22 @@ export async function collectUntilComplete(node, run, driver, ctx) {
             const data = projectCollectData(node, run.state);
             return normalizeTransition(await node.onComplete(data, run.state));
         }
+        // Acquire THIS turn's fresh input before extracting. If input is pending,
+        // consume it so extraction reads the user's actual reply. If nothing is
+        // pending AND the turn's input was already consumed by a prior node, pause:
+        // the prompt was presented on node-enter, so await the next turn rather than
+        // running extraction over stale history (which makes the model fabricate
+        // required fields). On the run's first input-node the turn's input is in
+        // `messages` with nothing pending and `turnInputConsumed` false, so we fall
+        // through and extract it.
+        if (hasPendingUserInput(ctx.session)) {
+            const signal = await driver.awaitUser(ctx);
+            appendUserMessage(run, signal.input);
+        }
+        else if (ctx.turnInputConsumed) {
+            return { kind: 'stay' };
+        }
+        ctx.turnInputConsumed = true;
         const turns = incrementCollectTurns(run.state, node.id);
         const maxTurns = node.maxTurns ?? 10;
         if (turns > maxTurns) {
@@ -33,14 +49,6 @@ export async function collectUntilComplete(node, run, driver, ctx) {
         const turn = await driver.runAgentTurn(resolved, ctx);
         mergeExtractionFromTurn(node, run, turn);
         appendAssistantMessage(run, turn.text);
-        if (schemaSatisfied(node, run.state)) {
-            continue;
-        }
-        if (!hasPendingUserInput(ctx.session)) {
-            return { kind: 'stay' };
-        }
-        const signal = await driver.awaitUser(ctx);
-        appendUserMessage(run, signal.input);
     }
 }
 function mergeExtractionFromTurn(node, run, turn) {

package/dist/flow/runFlow.js

@@ -61,13 +61,13 @@ async function dispatchNode(node, run, driver, ctx) {
         if (!driver.runStructured) {
             throw new Error('ChannelDriver.runStructured is required for decide nodes');
         }
-        // An interactive choice node (withChoices) reached without the user's reply
-        // this turn: its choices were already presented on node-enter, so wait for
-        // the user to actually pick rather than auto-deciding on stale conversation
-        // context. Returning `stay` lets the loop park as `awaitingUser` (it already
-        // persists state + ends the turn when no input is pending). (A plain decide
-        // with no choices is a pure branch and still runs.)
-        if (node.choices?.length && !hasPendingUserInput(ctx.session)) {
+        // An interactive choice node (withChoices) reached when the turn's input was
+        // already consumed by a prior node: its choices were presented on node-enter,
+        // so wait for the user to actually pick rather than auto-deciding on stale
+        // context. Returning `stay` lets the loop park as `awaitingUser`. (A plain
+        // decide with no choices is a pure branch and still runs; and an interactive
+        // decide that IS the turn's first input-node still decides on that input.)
+        if (node.choices?.length && !hasPendingUserInput(ctx.session) && ctx.turnInputConsumed) {
             return { kind: 'stay' };
         }
         // On resume, the new turn's input is buffered as pending and is not yet in
@@ -79,6 +79,8 @@ async function dispatchNode(node, run, driver, ctx) {
             const signal = await driver.awaitUser(ctx);
             appendUserMessage(run, signal.input);
         }
+        // This decide consumes the turn's input for its decision.
+        ctx.turnInputConsumed = true;
         const structured = await driver.runStructured(node, ctx);
         return normalizeTransition(await node.decide(structured, run.state));
     }

package/dist/runtime/ctx.js

@@ -108,6 +108,7 @@ function makeCtx(deps) {
         memoryService: deps.memoryService,
         bargeIn: deps.bargeIn,
         abortSignal: deps.abortSignal,
+        turnInputConsumed: false,
         tool: async (name, args, options) => {
             // needsApproval gate: a tool flagged `needsApproval` must be approved by a human
             // before it runs. Approval is a durable pause (the `__approval` signal); on resume

package/dist/types/run-context.d.ts

@@ -49,6 +49,14 @@ export interface RunContext {
     bargeIn?: AbortSignal;
     abortSignal?: AbortSignal;
     telemetry?: TelemetrySettings;
+    /**
+     * Ephemeral, per-run-invocation flag: has the current turn's user input been
+     * consumed yet by an input-node (collect/decide)? Input-nodes extract/decide
+     * from the turn's fresh input; once it is consumed, later nodes in the same
+     * turn pause (present prompt, await next turn) instead of acting on stale
+     * context. Reset to false on every `createRunContext` (i.e. every turn).
+     */
+    turnInputConsumed?: boolean;
     tool(name: string, args: unknown, options?: {
         toolCallId?: string;
         def?: AnyTool;

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/kuralle/kuralle-agents.git",
     "directory": "packages/kuralle-core"
   },
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "A framework for structured conversational AI agents",
   "publishConfig": {
     "access": "public"
@@ -97,7 +97,7 @@
     "dotenv": "^16.4.0",
     "typescript": "^5.3.0",
     "zod": "^3.23.0",
-    "@kuralle-agents/realtime-audio": "0.3.2"
+    "@kuralle-agents/realtime-audio": "0.3.3"
   },
   "dependencies": {
     "chrono-node": "^2.6.0",