@qafka/react-native 2.3.8 → 2.3.9

package/dist/components/ChatPage.js

@@ -60,7 +60,9 @@ function ChatPage({ displayMessages, isTyping, isSending, streamingMessage, tool
  </react_native_1.View>)}
 
  {/* Message List */}
- <react_native_1.FlatList ref={flatListRef} data={displayMessages} renderItem={renderMessage} keyExtractor={(item) => item.id} style={{ flex: 1, flexGrow: 1, flexShrink: 1 }} contentContainerStyle={styles.messageListStyle} ListEmptyComponent={renderEmpty} showsVerticalScrollIndicator={false} keyboardShouldPersistTaps="handled" onContentSizeChange={() => {
+ <react_native_1.FlatList ref={flatListRef} data={displayMessages} renderItem={renderMessage} keyExtractor={(item) => item.id} style={{ flex: 1, flexGrow: 1, flexShrink: 1 }} contentContainerStyle={styles.messageListStyle} ListEmptyComponent={renderEmpty} showsVerticalScrollIndicator={false} keyboardShouldPersistTaps="handled" ListFooterComponent={toolStatus ? (<react_native_1.View style={{ paddingHorizontal: 8, paddingTop: 4, alignItems: 'flex-start' }}>
+ <ToolStatusPill_1.ToolStatusPill message={toolStatus.message} theme={theme}/>
+ </react_native_1.View>) : null} onContentSizeChange={() => {
             if (displayMessages.length > 0) {
                 flatListRef.current?.scrollToEnd({ animated: true });
             }
@@ -71,10 +73,8 @@ function ChatPage({ displayMessages, isTyping, isSending, streamingMessage, tool
  <TypingIndicator_1.TypingIndicator theme={theme}/>
  </react_native_1.View>)}
 
- {/* Tool Status Pill (server-managed modes) */}
- {toolStatus && (<react_native_1.View style={{ paddingHorizontal: 8, alignItems: 'flex-start' }}>
- <ToolStatusPill_1.ToolStatusPill message={toolStatus.message} theme={theme}/>
- </react_native_1.View>)}
+ {/* Tool Status Pill now renders inside the list (ListFooterComponent)
+        so it sits directly under the last message and scrolls with it. */}
 
  {/* Input Area — hidden until SDK is ready so users can't type a message
         that would be rejected by an un-attested send. TypingIndicator in the

package/dist/decide-interrupt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns true when a realtime event signals a server-side interruption
+ * (user barge-in), so the caller can stop audio playback and let the user's
+ * new turn take over. Kept as a pure function so the decision is unit-testable
+ * without loading the native-bound RealtimeService.
+ */
+export declare function shouldStopPlayback(event: {
+    type?: string;
+} | null | undefined): boolean;

package/dist/decide-interrupt.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldStopPlayback = shouldStopPlayback;
+/**
+ * Returns true when a realtime event signals a server-side interruption
+ * (user barge-in), so the caller can stop audio playback and let the user's
+ * new turn take over. Kept as a pure function so the decision is unit-testable
+ * without loading the native-bound RealtimeService.
+ */
+function shouldStopPlayback(event) {
+    return event?.type === 'response.interrupted';
+}

package/dist/hooks/useChatMessages.js

@@ -4,6 +4,9 @@ exports.useChatMessages = void 0;
 const react_1 = require("react");
 const QafkaSDK_1 = require("../QafkaSDK");
 const Qafka_utils_1 = require("../components/Qafka.utils");
+const joinNarration_1 = require("../utils/joinNarration");
+const extractionContinuation_1 = require("../utils/extractionContinuation");
+const toolNarration_1 = require("../utils/toolNarration");
 /**
  * Custom hook for managing chat messages and sending
  */
@@ -32,29 +35,47 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
     const lastConversationIdRef = (0, react_1.useRef)(null);
     // guard against double-fire of postToolResult per toolKey
     const inFlightPostToolResultRef = (0, react_1.useRef)(new Set());
+    // The most recent suggested tool that is BOTH multi-step and file-input.
+    // Uploading + extracting a file does not start a new model turn on its own,
+    // so when extraction completes we fire a hidden continuation turn (tools
+    // enabled) to let the model advance to the next step. Captured here at
+    // suggestion time because the extraction callback only carries the result,
+    // not the tool definition.
+    const activeMultiStepFileToolRef = (0, react_1.useRef)(null);
+    // Always-current `context` so a deferred send (the post-extraction
+    // continuation) reads the consumer's freshly-updated context (e.g. a CV
+    // summary it set in onExtractionResult) rather than a stale closure value.
+    const contextRef = (0, react_1.useRef)(context);
+    contextRef.current = context;
     const scrollToBottom = (animated = true) => {
         setTimeout(() => {
             flatListRef.current?.scrollToEnd({ animated });
         }, 100);
     };
-    const handleSend = async (message) => {
+    // `hidden` turns send a message to the backend WITHOUT rendering a user
+    // bubble — used to auto-advance a tool flow (e.g. after a file upload) where
+    // the "message" is a system continuation the end user never typed.
+    const handleSend = async (message, options) => {
         if (isSending)
             return;
+        const hidden = options?.hidden === true;
         setIsSending(true);
         setIsTyping(true);
         setStreamingMessage('');
         finalChunkBufferRef.current = '';
-        // Add user message
-        const userMessage = {
-            id: Date.now().toString(),
-            role: 'user',
-            text: message,
-            content: message,
-            timestamp: new Date(),
-        };
-        setMessages((prev) => [...prev, userMessage]);
-        onMessageSent?.(message);
-        scrollToBottom();
+        // Add user message (skipped for hidden continuation turns)
+        if (!hidden) {
+            const userMessage = {
+                id: Date.now().toString(),
+                role: 'user',
+                text: message,
+                content: message,
+                timestamp: new Date(),
+            };
+            setMessages((prev) => [...prev, userMessage]);
+            onMessageSent?.(message);
+            scrollToBottom();
+        }
         const messageToSendAI = contextDescription
             ? `${contextDescription}\n\n${message}`
             : message;
@@ -179,7 +200,7 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                 // onError
                 (err) => {
                     handleError(err);
-                }, context, contextDescription, 
+                }, contextRef.current, contextDescription, 
                 // onToolSuggested
                 async (tools, conversationId, messageId) => {
                     if (conversationId) {
@@ -188,6 +209,12 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                     if (messageId) {
                         lastMessageIdRef.current = messageId;
                     }
+                    // Remember a multi-step file tool so a completed extraction can
+                    // auto-advance the flow (see the onExtractionResult handler below).
+                    const multiStepFileTool = (tools || []).find(extractionContinuation_1.isMultiStepFileTool);
+                    if (multiStepFileTool) {
+                        activeMultiStepFileToolRef.current = multiStepFileTool;
+                    }
                     if (onToolSuggested) {
                         // Tracks tools the consumer's `onToolSuggested` handler explicitly
                         // called `addResponse` for. The auto-fire loop below uses this — NOT
@@ -251,7 +278,13 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                             // In managed follow-up mode the SDK should POST the
                             // tool result back to the backend, which runs a second LLM turn
                             // and streams a `final_chunk` reply.
-                            if (commits && tool?.executionMode === 'custom-with-ai') {
+                            //
+                            // Skipped for card-rendering tools: there the model's first reply
+                            // (bridge) already carries the conversation and the card shows the
+                            // data, so the turn-2 narration only repeats it in a second message.
+                            if (commits &&
+                                tool?.executionMode === 'custom-with-ai' &&
+                                !(0, toolNarration_1.shouldSkipTurn2Narration)(tool)) {
                                 const conversationId = lastConversationIdRef.current;
                                 const messageId = lastMessageIdRef.current;
                                 if (conversationId && messageId) {
@@ -288,7 +321,10 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                                             setMessages((prev) => {
                                                 const lastMsg = prev[prev.length - 1];
                                                 if (lastMsg && lastMsg.role === 'assistant') {
-                                                    const nextText = (lastMsg.text || '') + content;
+                                                    // Turn-2 (post file-upload) narration appends to the same bubble; keep a
+                                                    // paragraph break so it doesn't glue onto turn-1 ("..yeterli!Harika!").
+                                                    // Matches the streaming path's separator and the backend persisted join.
+                                                    const nextText = (0, joinNarration_1.joinNarration)(lastMsg.text || '', content);
                                                     return [
                                                         ...prev.slice(0, -1),
                                                         {
@@ -401,8 +437,26 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                     }
                     onFileUploadRequest?.(request);
                 }, 
-                // onExtractionResult
-                onExtractionResult, 
+                // onExtractionResult — forward to consumer, then auto-advance multi-step
+                // file flows. A completed extraction does not start a new model turn by
+                // itself, so we fire a hidden continuation turn (tools enabled) carrying
+                // the extracted fields, letting the model proceed to the next step.
+                (result) => {
+                    onExtractionResult?.(result);
+                    const tool = activeMultiStepFileToolRef.current;
+                    if ((0, extractionContinuation_1.shouldAutoContinueAfterExtraction)({
+                        isMultiStepFileTool: !!tool,
+                        extractionStatus: result?.status,
+                    })) {
+                        activeMultiStepFileToolRef.current = null;
+                        // A completed extraction does not start a new model turn by itself; fire a
+                        // hidden continuation (tools enabled) carrying the extracted fields inline
+                        // so the model reliably advances to the next step.
+                        void handleSend((0, extractionContinuation_1.buildExtractionContinuationMessage)(result?.data), {
+                            hidden: true,
+                        });
+                    }
+                }, 
                 // onToolStatus: show pill
                 (status) => {
                     setToolStatus(status);
@@ -439,15 +493,12 @@ const useChatMessages = ({ enableStreaming = true, context = {}, contextDescript
                     setToolStatus(null);
                     finalChunkBufferRef.current +=
                         (finalChunkBufferRef.current ? '\n\n' : '') + content;
-                    setStreamingMessage((prev) => {
-                        const sep = prev && !prev.endsWith('\n') ? '\n\n' : '';
-                        return prev + sep + content;
-                    });
+                    setStreamingMessage((prev) => (0, joinNarration_1.joinNarration)(prev, content));
                 });
             }
             else {
                 // Non-streaming
-                const response = await sdk.sendMessage(message, context, contextDescription);
+                const response = await sdk.sendMessage(message, contextRef.current, contextDescription);
                 const aiMessage = {
                     id: response.id,
                     role: 'assistant',

package/dist/hooks/useVoiceChat.js

@@ -131,6 +131,22 @@ function useVoiceChat({ apiUrl, apiKey, userContext, contextDescription, onToolS
                 }
                 return;
             }
+            case 'response.interrupted': {
+                // Barge-in: the user cut in. RealtimeService already stopped native
+                // playback; finalize the partial AI turn (matching the server, which
+                // persists what was already streamed) and return to listening.
+                const partialAi = transcriptRef.current;
+                if (partialAi && partialAi.trim().length > 0) {
+                    setTranscriptHistory((h) => [
+                        ...h,
+                        { id: `a_${Date.now()}_${h.length}`, role: 'assistant', text: partialAi },
+                    ]);
+                }
+                transcriptRef.current = '';
+                setTranscript('');
+                setState('listening');
+                return;
+            }
             case 'session.closed':
                 setState('idle');
                 setNavigationSuggestion(null);

package/dist/services/RealtimeService.d.ts

@@ -11,6 +11,8 @@ export type RealtimeEvent = {
     delta: string;
 } | {
     type: 'response.done';
+} | {
+    type: 'response.interrupted';
 } | {
     type: 'conversation.item.input_audio_transcription.completed';
     transcript: string;

package/dist/services/RealtimeService.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RealtimeService = void 0;
 const QafkaAudio_1 = require("../native/QafkaAudio");
 const QafkaAttestation_1 = require("../native/QafkaAttestation");
+const decide_interrupt_1 = require("../decide-interrupt");
 class RealtimeService {
     apiUrl;
     apiKey;
@@ -121,6 +122,12 @@ class RealtimeService {
                 // playback errors are surfaced to the consumer via eventHandler
             });
         }
+        else if ((0, decide_interrupt_1.shouldStopPlayback)(event)) {
+            // Barge-in: the server signalled the user interrupted. Purge native
+            // playback so queued audio stops; the WS is ordered, so no further
+            // audio delta arrives after this for the cancelled turn.
+            QafkaAudio_1.QafkaAudio.stopPlayback().catch(() => { });
+        }
         this.eventHandler?.(event);
     }
     attachAudioListener() {

package/dist/utils/extractionContinuation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for auto-continuing a multi-step file-input tool flow after a
+ * document is uploaded and its fields are extracted.
+ *
+ * Background: uploading a file + extracting its fields does NOT, on its own,
+ * start a new model turn. Only a fresh `/chat` turn re-enables tools, which is
+ * what lets the model advance to the next step (e.g. ask the first question).
+ * For multi-step file tools we therefore fire a hidden continuation turn that
+ * carries the extracted fields so the model can proceed.
+ *
+ * These helpers are intentionally generic — they know nothing about any
+ * specific tool, field name, or domain.
+ */
+/** A suggested tool spans multiple steps AND collects a file when it exposes
+ * both a `step` parameter and a file-input module. Single-shot file tools
+ * (extract → render → done) are excluded. */
+export declare function isMultiStepFileTool(tool: any): boolean;
+/** Auto-advance only once a multi-step file tool's extraction has completed.
+ * Incomplete extractions and single-shot tools stay on the normal path. */
+export declare function shouldAutoContinueAfterExtraction(args: {
+    isMultiStepFileTool: boolean;
+    extractionStatus?: string;
+}): boolean;
+/** Build the hidden continuation message. The extracted fields are embedded
+ * inline as JSON: in practice the model only reliably uses the values (and
+ * stays on-script / in-language) when they are present in the message itself —
+ * a generic "read it from context" trigger derails it. The data IS also in the
+ * `context` prop, but this inline copy is what keeps the continuation reliable.
+ * Keeping it out of the persisted transcript is handled separately, server side,
+ * not by stripping it here.
+ */
+export declare function buildExtractionContinuationMessage(data: Record<string, any> | undefined | null): string;

package/dist/utils/extractionContinuation.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Helpers for auto-continuing a multi-step file-input tool flow after a
+ * document is uploaded and its fields are extracted.
+ *
+ * Background: uploading a file + extracting its fields does NOT, on its own,
+ * start a new model turn. Only a fresh `/chat` turn re-enables tools, which is
+ * what lets the model advance to the next step (e.g. ask the first question).
+ * For multi-step file tools we therefore fire a hidden continuation turn that
+ * carries the extracted fields so the model can proceed.
+ *
+ * These helpers are intentionally generic — they know nothing about any
+ * specific tool, field name, or domain.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultiStepFileTool = isMultiStepFileTool;
+exports.shouldAutoContinueAfterExtraction = shouldAutoContinueAfterExtraction;
+exports.buildExtractionContinuationMessage = buildExtractionContinuationMessage;
+/** A suggested tool spans multiple steps AND collects a file when it exposes
+ * both a `step` parameter and a file-input module. Single-shot file tools
+ * (extract → render → done) are excluded. */
+function isMultiStepFileTool(tool) {
+    const params = tool?.parameters;
+    const hasStep = !!params && typeof params === 'object' && 'step' in params;
+    return Boolean(tool?.modules?.hasFileInput) && hasStep;
+}
+/** Auto-advance only once a multi-step file tool's extraction has completed.
+ * Incomplete extractions and single-shot tools stay on the normal path. */
+function shouldAutoContinueAfterExtraction(args) {
+    return args.isMultiStepFileTool && args.extractionStatus === 'complete';
+}
+/** Build the hidden continuation message. The extracted fields are embedded
+ * inline as JSON: in practice the model only reliably uses the values (and
+ * stays on-script / in-language) when they are present in the message itself —
+ * a generic "read it from context" trigger derails it. The data IS also in the
+ * `context` prop, but this inline copy is what keeps the continuation reliable.
+ * Keeping it out of the persisted transcript is handled separately, server side,
+ * not by stripping it here.
+ */
+function buildExtractionContinuationMessage(data) {
+    const fields = data && typeof data === 'object' ? JSON.stringify(data) : '{}';
+    return [
+        '[Uploaded document — extracted fields]',
+        fields,
+        '',
+        '(The user just uploaded a document and it was processed. Use these fields to continue the tool flow — proceed to the next step. Do not restart or repeat the greeting.)',
+    ].join('\n');
+}

package/dist/utils/joinNarration.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Joins two pieces of assistant narration into a single text body with a
+ * consistent paragraph break.
+ *
+ * A custom-with-ai tool produces a reply in two streamed parts (e.g. a first
+ * reply, then a follow-up after a file upload). Those parts land in the same
+ * assistant bubble, so they must be separated the same way everywhere — both in
+ * the live render and in what the backend persists — otherwise the live text
+ * comes out glued together with no break (".. yeterli!Harika! ..").
+ *
+ * Rules: empty parts pass through untouched; if `prev` already ends with a
+ * newline, no extra break is added; otherwise the two parts are joined with a
+ * blank line.
+ */
+export declare function joinNarration(prev: string, next: string): string;

package/dist/utils/joinNarration.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinNarration = joinNarration;
+/**
+ * Joins two pieces of assistant narration into a single text body with a
+ * consistent paragraph break.
+ *
+ * A custom-with-ai tool produces a reply in two streamed parts (e.g. a first
+ * reply, then a follow-up after a file upload). Those parts land in the same
+ * assistant bubble, so they must be separated the same way everywhere — both in
+ * the live render and in what the backend persists — otherwise the live text
+ * comes out glued together with no break (".. yeterli!Harika! ..").
+ *
+ * Rules: empty parts pass through untouched; if `prev` already ends with a
+ * newline, no extra break is added; otherwise the two parts are joined with a
+ * blank line.
+ */
+function joinNarration(prev, next) {
+    if (!prev)
+        return next || '';
+    if (!next)
+        return prev;
+    const sep = prev.endsWith('\n') ? '' : '\n\n';
+    return prev + sep + next;
+}

package/dist/utils/toolNarration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether to skip the turn-2 narration (the post-tool-result round-trip) for a
+ * suggested tool.
+ *
+ * custom-with-ai tools answer in two streamed parts: the model's first reply
+ * (the "bridge", produced alongside the tool call) and a turn-2 narration of
+ * the tool result. When the tool renders its result as a CARD, the bridge
+ * already carries the conversational text and the card shows the data, so the
+ * turn-2 text narration is redundant — it just repeats the bridge in a second
+ * message. We skip it for those tools.
+ *
+ * Tools WITHOUT a card are left untouched: there the substantive answer often
+ * lives only in the turn-2 narration (e.g. a lookup whose bridge is a short
+ * "one moment" filler), so it must still run.
+ */
+export declare function shouldSkipTurn2Narration(tool: any): boolean;

package/dist/utils/toolNarration.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipTurn2Narration = shouldSkipTurn2Narration;
+/**
+ * Whether to skip the turn-2 narration (the post-tool-result round-trip) for a
+ * suggested tool.
+ *
+ * custom-with-ai tools answer in two streamed parts: the model's first reply
+ * (the "bridge", produced alongside the tool call) and a turn-2 narration of
+ * the tool result. When the tool renders its result as a CARD, the bridge
+ * already carries the conversational text and the card shows the data, so the
+ * turn-2 text narration is redundant — it just repeats the bridge in a second
+ * message. We skip it for those tools.
+ *
+ * Tools WITHOUT a card are left untouched: there the substantive answer often
+ * lives only in the turn-2 narration (e.g. a lookup whose bridge is a short
+ * "one moment" filler), so it must still run.
+ */
+function shouldSkipTurn2Narration(tool) {
+    return (tool?.executionMode === 'custom-with-ai' &&
+        tool?.uiConfig?.responseType === 'card');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qafka/react-native",
-  "version": "2.3.8",
+  "version": "2.3.9",
   "description": "Drop-in AI assistant for React Native: chat, voice, and tool execution with screen-aware navigation.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",