expo-ai-kit 0.1.15 → 0.1.16

package/README.md

@@ -28,7 +28,8 @@ On-device AI for Expo apps. Run language models locally—no API keys, no cloud,
 - **Free forever** — No API costs, rate limits, or subscriptions
 - **Native performance** — Built on Apple Foundation Models (iOS) and Google ML Kit Prompt API (Android)
 - **Multi-turn conversations** — Full conversation context support
-- **Simple API** — Just 2 functions: `isAvailable()` and `sendMessage()`
+- **Streaming support** — Progressive token streaming for responsive UIs
+- **Simple API** — Just 3 functions: `isAvailable()`, `sendMessage()`, and `streamMessage()`
 
 ## Requirements
 
@@ -142,6 +143,79 @@ const response = await sendMessage(conversation, {
 console.log(response.text); // "Your name is Alice."
 ```
 
+### Streaming Responses
+
+For a ChatGPT-like experience where text appears progressively:
+
+```tsx
+import { streamMessage } from 'expo-ai-kit';
+
+const [responseText, setResponseText] = useState('');
+
+const { promise, stop } = streamMessage(
+  [{ role: 'user', content: 'Tell me a story' }],
+  (event) => {
+    // Update UI with each token
+    setResponseText(event.accumulatedText);
+
+    // event.token - the new token/chunk
+    // event.accumulatedText - full text so far
+    // event.isDone - whether streaming is complete
+  },
+  { systemPrompt: 'You are a creative storyteller.' }
+);
+
+// Optionally cancel the stream
+// stop();
+
+// Wait for completion
+await promise;
+```
+
+### Streaming with Cancel Button
+
+```tsx
+import { useState, useRef } from 'react';
+import { streamMessage } from 'expo-ai-kit';
+
+function ChatWithStreaming() {
+  const [text, setText] = useState('');
+  const [isStreaming, setIsStreaming] = useState(false);
+  const stopRef = useRef<(() => void) | null>(null);
+
+  const handleSend = async () => {
+    setIsStreaming(true);
+    setText('');
+
+    const { promise, stop } = streamMessage(
+      [{ role: 'user', content: 'Write a long story' }],
+      (event) => setText(event.accumulatedText)
+    );
+
+    stopRef.current = stop;
+    await promise;
+    stopRef.current = null;
+    setIsStreaming(false);
+  };
+
+  const handleStop = () => {
+    stopRef.current?.();
+    setIsStreaming(false);
+  };
+
+  return (
+    <View>
+      <Text>{text}</Text>
+      {isStreaming ? (
+        <Button title="Stop" onPress={handleStop} />
+      ) : (
+        <Button title="Send" onPress={handleSend} />
+      )}
+    </View>
+  );
+}
+```
+
 ### Complete Chat Example
 
 Here's a full cross-platform chat component:
@@ -264,6 +338,48 @@ console.log(response.text); // "Ahoy, matey!"
 
 ---
 
+### `streamMessage(messages, onToken, options?)`
+
+Streams a conversation response with progressive token updates. Ideal for responsive chat UIs.
+
+```typescript
+function streamMessage(
+  messages: LLMMessage[],
+  onToken: LLMStreamCallback,
+  options?: LLMStreamOptions
+): { promise: Promise<LLMResponse>; stop: () => void }
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `messages` | `LLMMessage[]` | Array of conversation messages |
+| `onToken` | `LLMStreamCallback` | Callback called for each token received |
+| `options.systemPrompt` | `string` | Fallback system prompt (ignored if messages contain a system message) |
+
+**Returns:** Object with:
+- `promise: Promise<LLMResponse>` — Resolves when streaming completes
+- `stop: () => void` — Function to cancel the stream
+
+**Example:**
+```tsx
+const { promise, stop } = streamMessage(
+  [{ role: 'user', content: 'Hello!' }],
+  (event) => {
+    console.log(event.token);           // New token: "Hi"
+    console.log(event.accumulatedText); // Full text: "Hi there!"
+    console.log(event.isDone);          // false until complete
+  }
+);
+
+// Cancel if needed
+setTimeout(() => stop(), 5000);
+
+// Wait for completion
+const response = await promise;
+```
+
+---
+
 ### Types
 
 ```typescript
@@ -279,10 +395,28 @@ type LLMSendOptions = {
   systemPrompt?: string;
 };
 
+type LLMStreamOptions = {
+  /** Fallback system prompt if no system message in messages array */
+  systemPrompt?: string;
+};
+
 type LLMResponse = {
   /** The generated response text */
   text: string;
 };
+
+type LLMStreamEvent = {
+  /** Unique identifier for this streaming session */
+  sessionId: string;
+  /** The token/chunk of text received */
+  token: string;
+  /** Accumulated text so far */
+  accumulatedText: string;
+  /** Whether this is the final chunk */
+  isDone: boolean;
+};
+
+type LLMStreamCallback = (event: LLMStreamEvent) => void;
 ```
 
 ## Feature Comparison
@@ -291,8 +425,10 @@ type LLMResponse = {
 |---------|---------|---------------------|
 | `isAvailable()` | ✅ | ✅ |
 | `sendMessage()` | ✅ | ✅ |
+| `streamMessage()` | ✅ | ✅ |
 | System prompts | ✅ Native | ✅ Prepended |
 | Multi-turn context | ✅ | ✅ |
+| Cancel streaming | ✅ | ✅ |
 
 ## How It Works
 
@@ -312,7 +448,7 @@ Uses Google's ML Kit Prompt API. The model may need to be downloaded on first us
 - **Empty responses**: The device may not support ML Kit Prompt API. Check the [supported devices list](https://developers.google.com/ml-kit/genai#prompt-device)
 - **Model downloading**: On first use, the model may need to download. Use `isAvailable()` to check status
 
-## Migration from v0.1.x
+## Migration from v0.1.4
 
 If you're upgrading from an earlier version, here are the breaking changes:
 
@@ -335,6 +471,17 @@ const { reply } = await sendMessage(sessionId, messages, {});
 const { text } = await sendMessage(messages, { systemPrompt: '...' });
 ```
 
+## Roadmap
+
+| Feature | Status | Priority |
+|---------|--------|----------|
+| ✅ Streaming responses | Done | - |
+| Prompt helpers (summarize, translate, etc.) | Planned | Medium |
+| Web/generic fallback | Idea | Medium |
+| Configurable hyperparameters (temperature, etc.) | Idea | Low |
+
+Have a feature request? [Open an issue](https://github.com/laraelmas/expo-ai-kit/issues)!
+
 ## License
 
 MIT

package/android/src/main/java/expo/modules/aikit/ExpoAiKitModule.kt

@@ -3,14 +3,24 @@ package expo.modules.aikit
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.functions.Coroutine
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.cancel
 
 class ExpoAiKitModule : Module() {
 
   private val promptClient by lazy { PromptApiClient() }
+  private val activeStreamJobs = mutableMapOf<String, Job>()
+  private val streamScope = CoroutineScope(Dispatchers.IO)
 
   override fun definition() = ModuleDefinition {
     Name("ExpoAiKit")
 
+    // Declare events that can be sent to JavaScript
+    Events("onStreamToken")
+
     Function("isAvailable") {
       promptClient.isAvailableBlocking()
     }
@@ -31,5 +41,42 @@ class ExpoAiKitModule : Module() {
       val text = promptClient.generateText(userPrompt, systemPrompt)
       mapOf("text" to text)
     }
+
+    AsyncFunction("startStreaming") { messages: List<Map<String, Any>>, fallbackSystemPrompt: String, sessionId: String ->
+      // Extract system prompt from messages, or use fallback
+      val systemPrompt = messages
+        .firstOrNull { it["role"] == "system" }
+        ?.get("content") as? String
+        ?: fallbackSystemPrompt.ifBlank { "You are a helpful, friendly assistant." }
+
+      // Get the last user message as the prompt
+      val userPrompt = messages
+        .lastOrNull { it["role"] == "user" }
+        ?.get("content") as? String
+        ?: ""
+
+      // Launch streaming in a coroutine that can be cancelled
+      val job = streamScope.launch {
+        promptClient.generateTextStream(userPrompt, systemPrompt) { token, accumulatedText, isDone ->
+          sendEvent("onStreamToken", mapOf(
+            "sessionId" to sessionId,
+            "token" to token,
+            "accumulatedText" to accumulatedText,
+            "isDone" to isDone
+          ))
+
+          if (isDone) {
+            activeStreamJobs.remove(sessionId)
+          }
+        }
+      }
+
+      activeStreamJobs[sessionId] = job
+    }
+
+    AsyncFunction("stopStreaming") { sessionId: String ->
+      activeStreamJobs[sessionId]?.cancel()
+      activeStreamJobs.remove(sessionId)
+    }
   }
 }

package/android/src/main/java/expo/modules/aikit/PromptApiClient.kt

@@ -4,6 +4,8 @@ import android.os.Build
 import com.google.mlkit.genai.common.FeatureStatus
 import com.google.mlkit.genai.prompt.Generation
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 
@@ -64,4 +66,47 @@ class PromptApiClient {
         ""
       }
     }
+
+  /**
+   * Generate streaming text from a prompt.
+   * Returns a Flow that emits chunks of generated text.
+   */
+  suspend fun generateTextStream(
+    prompt: String,
+    systemPrompt: String,
+    onChunk: (token: String, accumulatedText: String, isDone: Boolean) -> Unit
+  ) = withContext(Dispatchers.IO) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      onChunk("", "", true)
+      return@withContext
+    }
+
+    try {
+      val status = model.checkStatus()
+      if (status != FeatureStatus.AVAILABLE) {
+        onChunk("", "", true)
+        return@withContext
+      }
+
+      // Prepend system prompt as context if provided
+      val fullPrompt = if (systemPrompt.isNotBlank()) {
+        "$systemPrompt\n\nUser: $prompt"
+      } else {
+        prompt
+      }
+
+      var accumulatedText = ""
+
+      model.generateContentStream(fullPrompt).collect { response ->
+        val newChunk = response.candidates.firstOrNull()?.text.orEmpty()
+        accumulatedText += newChunk
+        onChunk(newChunk, accumulatedText, false)
+      }
+
+      // Send final done event
+      onChunk("", accumulatedText, true)
+    } catch (e: Throwable) {
+      onChunk("", "[Error: ${e.message}]", true)
+    }
+  }
 }

package/build/ExpoAiKitModule.d.ts

@@ -1,8 +1,15 @@
-import { LLMMessage, LLMResponse } from './types';
-export type ExpoAiKitNativeModule = {
+import type { EventSubscription } from 'expo-modules-core';
+import { LLMMessage, LLMResponse, LLMStreamEvent } from './types';
+export type ExpoAiKitModuleEvents = {
+    onStreamToken: (event: LLMStreamEvent) => void;
+};
+export interface ExpoAiKitNativeModule {
     isAvailable(): boolean;
     sendMessage(messages: LLMMessage[], systemPrompt: string): Promise<LLMResponse>;
-};
-declare const NativeModule: ExpoAiKitNativeModule;
-export default NativeModule;
+    startStreaming(messages: LLMMessage[], systemPrompt: string, sessionId: string): Promise<void>;
+    stopStreaming(sessionId: string): Promise<void>;
+    addListener<K extends keyof ExpoAiKitModuleEvents>(eventName: K, listener: ExpoAiKitModuleEvents[K]): EventSubscription;
+}
+declare const ExpoAiKitModule: ExpoAiKitNativeModule;
+export default ExpoAiKitModule;
 //# sourceMappingURL=ExpoAiKitModule.d.ts.map

package/build/ExpoAiKitModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoAiKitModule.d.ts","sourceRoot":"","sources":["../src/ExpoAiKitModule.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,IAAI,OAAO,CAAC;IACvB,WAAW,CACT,QAAQ,EAAE,UAAU,EAAE,EACtB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB,CAAC;AAEF,QAAA,MAAM,YAAY,EAAE,qBACqC,CAAC;AAE1D,eAAe,YAAY,CAAC"}
+{"version":3,"file":"ExpoAiKitModule.d.ts","sourceRoot":"","sources":["../src/ExpoAiKitModule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAElE,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CAChD,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,WAAW,IAAI,OAAO,CAAC;IACvB,WAAW,CACT,QAAQ,EAAE,UAAU,EAAE,EACtB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAAC;IACxB,cAAc,CACZ,QAAQ,EAAE,UAAU,EAAE,EACtB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,WAAW,CAAC,CAAC,SAAS,MAAM,qBAAqB,EAC/C,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,iBAAiB,CAAC;CACtB;AAED,QAAA,MAAM,eAAe,uBACoC,CAAC;AAE1D,eAAe,eAAe,CAAC"}

package/build/ExpoAiKitModule.js

@@ -1,4 +1,4 @@
 import { requireNativeModule } from 'expo-modules-core';
-const NativeModule = requireNativeModule('ExpoAiKit');
-export default NativeModule;
+const ExpoAiKitModule = requireNativeModule('ExpoAiKit');
+export default ExpoAiKitModule;
 //# sourceMappingURL=ExpoAiKitModule.js.map

package/build/ExpoAiKitModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoAiKitModule.js","sourceRoot":"","sources":["../src/ExpoAiKitModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAWxD,MAAM,YAAY,GAChB,mBAAmB,CAAwB,WAAW,CAAC,CAAC;AAE1D,eAAe,YAAY,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\nimport { LLMMessage, LLMResponse } from './types';\n\nexport type ExpoAiKitNativeModule = {\n  isAvailable(): boolean;\n  sendMessage(\n    messages: LLMMessage[],\n    systemPrompt: string\n  ): Promise<LLMResponse>;\n};\n\nconst NativeModule: ExpoAiKitNativeModule =\n  requireNativeModule<ExpoAiKitNativeModule>('ExpoAiKit');\n\nexport default NativeModule;\n"]}
+{"version":3,"file":"ExpoAiKitModule.js","sourceRoot":"","sources":["../src/ExpoAiKitModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AA0BxD,MAAM,eAAe,GACnB,mBAAmB,CAAwB,WAAW,CAAC,CAAC;AAE1D,eAAe,eAAe,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\nimport type { EventSubscription } from 'expo-modules-core';\nimport { LLMMessage, LLMResponse, LLMStreamEvent } from './types';\n\nexport type ExpoAiKitModuleEvents = {\n  onStreamToken: (event: LLMStreamEvent) => void;\n};\n\nexport interface ExpoAiKitNativeModule {\n  isAvailable(): boolean;\n  sendMessage(\n    messages: LLMMessage[],\n    systemPrompt: string\n  ): Promise<LLMResponse>;\n  startStreaming(\n    messages: LLMMessage[],\n    systemPrompt: string,\n    sessionId: string\n  ): Promise<void>;\n  stopStreaming(sessionId: string): Promise<void>;\n  addListener<K extends keyof ExpoAiKitModuleEvents>(\n    eventName: K,\n    listener: ExpoAiKitModuleEvents[K]\n  ): EventSubscription;\n}\n\nconst ExpoAiKitModule =\n  requireNativeModule<ExpoAiKitNativeModule>('ExpoAiKit');\n\nexport default ExpoAiKitModule;\n"]}

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { LLMMessage, LLMSendOptions, LLMResponse } from './types';
+import { LLMMessage, LLMSendOptions, LLMResponse, LLMStreamOptions, LLMStreamCallback } from './types';
 export * from './types';
 /**
  * Check if on-device AI is available on the current device.
@@ -41,4 +41,52 @@ export declare function isAvailable(): Promise<boolean>;
  * ```
  */
 export declare function sendMessage(messages: LLMMessage[], options?: LLMSendOptions): Promise<LLMResponse>;
+/**
+ * Stream messages to the on-device LLM and receive progressive token updates.
+ *
+ * @param messages - Array of messages representing the conversation
+ * @param onToken - Callback function called for each token/chunk received
+ * @param options - Optional settings (systemPrompt fallback)
+ * @returns Object with stop() function to cancel streaming and promise that resolves when complete
+ *
+ * @example
+ * ```ts
+ * // Basic streaming
+ * const { promise } = streamMessage(
+ *   [{ role: 'user', content: 'Tell me a story' }],
+ *   (event) => {
+ *     console.log(event.token); // Each token as it arrives
+ *     console.log(event.accumulatedText); // Full text so far
+ *   }
+ * );
+ * await promise;
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cancellation
+ * const { promise, stop } = streamMessage(
+ *   [{ role: 'user', content: 'Write a long essay' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ *
+ * // Cancel after 5 seconds
+ * setTimeout(() => stop(), 5000);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // React state update pattern
+ * const [text, setText] = useState('');
+ *
+ * streamMessage(
+ *   [{ role: 'user', content: 'Hello!' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ * ```
+ */
+export declare function streamMessage(messages: LLMMessage[], onToken: LLMStreamCallback, options?: LLMStreamOptions): {
+    promise: Promise<LLMResponse>;
+    stop: () => void;
+};
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAElE,cAAc,SAAS,CAAC;AAKxB;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAKpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,WAAW,CAAC,CAgBtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,cAAc,EACd,WAAW,EACX,gBAAgB,EAEhB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB,cAAc,SAAS,CAAC;AAUxB;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAKpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,WAAW,CAAC,CAgBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,gBAAgB,GACzB;IAAE,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CAiErD"}

package/build/index.js

@@ -1,7 +1,11 @@
-import NativeModule from './ExpoAiKitModule';
+import ExpoAiKitModule from './ExpoAiKitModule';
 import { Platform } from 'react-native';
 export * from './types';
 const DEFAULT_SYSTEM_PROMPT = 'You are a helpful, friendly assistant. Answer the user directly and concisely.';
+let streamIdCounter = 0;
+function generateSessionId() {
+    return `stream_${Date.now()}_${++streamIdCounter}`;
+}
 /**
  * Check if on-device AI is available on the current device.
  * Returns false on unsupported platforms (web, etc.).
@@ -10,7 +14,7 @@ export async function isAvailable() {
     if (Platform.OS !== 'ios' && Platform.OS !== 'android') {
         return false;
     }
-    return NativeModule.isAvailable();
+    return ExpoAiKitModule.isAvailable();
 }
 /**
  * Send messages to the on-device LLM and get a response.
@@ -59,6 +63,103 @@ export async function sendMessage(messages, options) {
     const systemPrompt = hasSystemMessage
         ? '' // Native will extract from messages
         : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    return NativeModule.sendMessage(messages, systemPrompt);
+    return ExpoAiKitModule.sendMessage(messages, systemPrompt);
+}
+/**
+ * Stream messages to the on-device LLM and receive progressive token updates.
+ *
+ * @param messages - Array of messages representing the conversation
+ * @param onToken - Callback function called for each token/chunk received
+ * @param options - Optional settings (systemPrompt fallback)
+ * @returns Object with stop() function to cancel streaming and promise that resolves when complete
+ *
+ * @example
+ * ```ts
+ * // Basic streaming
+ * const { promise } = streamMessage(
+ *   [{ role: 'user', content: 'Tell me a story' }],
+ *   (event) => {
+ *     console.log(event.token); // Each token as it arrives
+ *     console.log(event.accumulatedText); // Full text so far
+ *   }
+ * );
+ * await promise;
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cancellation
+ * const { promise, stop } = streamMessage(
+ *   [{ role: 'user', content: 'Write a long essay' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ *
+ * // Cancel after 5 seconds
+ * setTimeout(() => stop(), 5000);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // React state update pattern
+ * const [text, setText] = useState('');
+ *
+ * streamMessage(
+ *   [{ role: 'user', content: 'Hello!' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ * ```
+ */
+export function streamMessage(messages, onToken, options) {
+    // Handle unsupported platforms
+    if (Platform.OS !== 'ios' && Platform.OS !== 'android') {
+        return {
+            promise: Promise.resolve({ text: '' }),
+            stop: () => { },
+        };
+    }
+    if (!messages || messages.length === 0) {
+        return {
+            promise: Promise.reject(new Error('messages array cannot be empty')),
+            stop: () => { },
+        };
+    }
+    const sessionId = generateSessionId();
+    let finalText = '';
+    let stopped = false;
+    // Determine system prompt: use from messages array if present, else options, else default
+    const hasSystemMessage = messages.some((m) => m.role === 'system');
+    const systemPrompt = hasSystemMessage
+        ? '' // Native will extract from messages
+        : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    const promise = new Promise((resolve, reject) => {
+        // Subscribe to stream events
+        const subscription = ExpoAiKitModule.addListener('onStreamToken', (event) => {
+            // Only process events for this session
+            if (event.sessionId !== sessionId)
+                return;
+            finalText = event.accumulatedText;
+            // Call the user's callback
+            onToken(event);
+            // If done, clean up and resolve
+            if (event.isDone) {
+                subscription.remove();
+                resolve({ text: finalText });
+            }
+        });
+        // Start streaming on native side
+        ExpoAiKitModule.startStreaming(messages, systemPrompt, sessionId).catch((error) => {
+            subscription.remove();
+            reject(error);
+        });
+    });
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        ExpoAiKitModule.stopStreaming(sessionId).catch(() => {
+            // Ignore errors when stopping
+        });
+    };
+    return { promise, stop };
 }
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxC,cAAc,SAAS,CAAC;AAExB,MAAM,qBAAqB,GACzB,gFAAgF,CAAC;AAEnF;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,YAAY,CAAC,WAAW,EAAE,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,QAAsB,EACtB,OAAwB;IAExB,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QACvD,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IACtB,CAAC;IAED,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,0FAA0F;IAC1F,MAAM,gBAAgB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IACnE,MAAM,YAAY,GAAG,gBAAgB;QACnC,CAAC,CAAC,EAAE,CAAC,oCAAoC;QACzC,CAAC,CAAC,OAAO,EAAE,YAAY,IAAI,qBAAqB,CAAC;IAEnD,OAAO,YAAY,CAAC,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;AAC1D,CAAC","sourcesContent":["import NativeModule from './ExpoAiKitModule';\nimport { Platform } from 'react-native';\nimport { LLMMessage, LLMSendOptions, LLMResponse } from './types';\n\nexport * from './types';\n\nconst DEFAULT_SYSTEM_PROMPT =\n  'You are a helpful, friendly assistant. Answer the user directly and concisely.';\n\n/**\n * Check if on-device AI is available on the current device.\n * Returns false on unsupported platforms (web, etc.).\n */\nexport async function isAvailable(): Promise<boolean> {\n  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {\n    return false;\n  }\n  return NativeModule.isAvailable();\n}\n\n/**\n * Send messages to the on-device LLM and get a response.\n *\n * @param messages - Array of messages representing the conversation\n * @param options - Optional settings (systemPrompt fallback)\n * @returns Promise with the generated response\n *\n * @example\n * ```ts\n * const response = await sendMessage([\n *   { role: 'user', content: 'What is 2 + 2?' }\n * ]);\n * console.log(response.text); // \"4\"\n * ```\n *\n * @example\n * ```ts\n * // With system prompt\n * const response = await sendMessage(\n *   [{ role: 'user', content: 'Hello!' }],\n *   { systemPrompt: 'You are a pirate. Respond in pirate speak.' }\n * );\n * ```\n *\n * @example\n * ```ts\n * // Multi-turn conversation\n * const response = await sendMessage([\n *   { role: 'system', content: 'You are a helpful assistant.' },\n *   { role: 'user', content: 'My name is Alice.' },\n *   { role: 'assistant', content: 'Nice to meet you, Alice!' },\n *   { role: 'user', content: 'What is my name?' }\n * ]);\n * ```\n */\nexport async function sendMessage(\n  messages: LLMMessage[],\n  options?: LLMSendOptions\n): Promise<LLMResponse> {\n  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {\n    return { text: '' };\n  }\n\n  if (!messages || messages.length === 0) {\n    throw new Error('messages array cannot be empty');\n  }\n\n  // Determine system prompt: use from messages array if present, else options, else default\n  const hasSystemMessage = messages.some((m) => m.role === 'system');\n  const systemPrompt = hasSystemMessage\n    ? '' // Native will extract from messages\n    : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;\n\n  return NativeModule.sendMessage(messages, systemPrompt);\n}\n\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import ExpoAiKitModule from './ExpoAiKitModule';\nimport { Platform } from 'react-native';\nimport {\n  LLMMessage,\n  LLMSendOptions,\n  LLMResponse,\n  LLMStreamOptions,\n  LLMStreamEvent,\n  LLMStreamCallback,\n} from './types';\n\nexport * from './types';\n\nconst DEFAULT_SYSTEM_PROMPT =\n  'You are a helpful, friendly assistant. Answer the user directly and concisely.';\n\nlet streamIdCounter = 0;\nfunction generateSessionId(): string {\n  return `stream_${Date.now()}_${++streamIdCounter}`;\n}\n\n/**\n * Check if on-device AI is available on the current device.\n * Returns false on unsupported platforms (web, etc.).\n */\nexport async function isAvailable(): Promise<boolean> {\n  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {\n    return false;\n  }\n  return ExpoAiKitModule.isAvailable();\n}\n\n/**\n * Send messages to the on-device LLM and get a response.\n *\n * @param messages - Array of messages representing the conversation\n * @param options - Optional settings (systemPrompt fallback)\n * @returns Promise with the generated response\n *\n * @example\n * ```ts\n * const response = await sendMessage([\n *   { role: 'user', content: 'What is 2 + 2?' }\n * ]);\n * console.log(response.text); // \"4\"\n * ```\n *\n * @example\n * ```ts\n * // With system prompt\n * const response = await sendMessage(\n *   [{ role: 'user', content: 'Hello!' }],\n *   { systemPrompt: 'You are a pirate. Respond in pirate speak.' }\n * );\n * ```\n *\n * @example\n * ```ts\n * // Multi-turn conversation\n * const response = await sendMessage([\n *   { role: 'system', content: 'You are a helpful assistant.' },\n *   { role: 'user', content: 'My name is Alice.' },\n *   { role: 'assistant', content: 'Nice to meet you, Alice!' },\n *   { role: 'user', content: 'What is my name?' }\n * ]);\n * ```\n */\nexport async function sendMessage(\n  messages: LLMMessage[],\n  options?: LLMSendOptions\n): Promise<LLMResponse> {\n  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {\n    return { text: '' };\n  }\n\n  if (!messages || messages.length === 0) {\n    throw new Error('messages array cannot be empty');\n  }\n\n  // Determine system prompt: use from messages array if present, else options, else default\n  const hasSystemMessage = messages.some((m) => m.role === 'system');\n  const systemPrompt = hasSystemMessage\n    ? '' // Native will extract from messages\n    : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;\n\n  return ExpoAiKitModule.sendMessage(messages, systemPrompt);\n}\n\n/**\n * Stream messages to the on-device LLM and receive progressive token updates.\n *\n * @param messages - Array of messages representing the conversation\n * @param onToken - Callback function called for each token/chunk received\n * @param options - Optional settings (systemPrompt fallback)\n * @returns Object with stop() function to cancel streaming and promise that resolves when complete\n *\n * @example\n * ```ts\n * // Basic streaming\n * const { promise } = streamMessage(\n *   [{ role: 'user', content: 'Tell me a story' }],\n *   (event) => {\n *     console.log(event.token); // Each token as it arrives\n *     console.log(event.accumulatedText); // Full text so far\n *   }\n * );\n * await promise;\n * ```\n *\n * @example\n * ```ts\n * // With cancellation\n * const { promise, stop } = streamMessage(\n *   [{ role: 'user', content: 'Write a long essay' }],\n *   (event) => setText(event.accumulatedText)\n * );\n *\n * // Cancel after 5 seconds\n * setTimeout(() => stop(), 5000);\n * ```\n *\n * @example\n * ```ts\n * // React state update pattern\n * const [text, setText] = useState('');\n *\n * streamMessage(\n *   [{ role: 'user', content: 'Hello!' }],\n *   (event) => setText(event.accumulatedText)\n * );\n * ```\n */\nexport function streamMessage(\n  messages: LLMMessage[],\n  onToken: LLMStreamCallback,\n  options?: LLMStreamOptions\n): { promise: Promise<LLMResponse>; stop: () => void } {\n  // Handle unsupported platforms\n  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {\n    return {\n      promise: Promise.resolve({ text: '' }),\n      stop: () => {},\n    };\n  }\n\n  if (!messages || messages.length === 0) {\n    return {\n      promise: Promise.reject(new Error('messages array cannot be empty')),\n      stop: () => {},\n    };\n  }\n\n  const sessionId = generateSessionId();\n  let finalText = '';\n  let stopped = false;\n\n  // Determine system prompt: use from messages array if present, else options, else default\n  const hasSystemMessage = messages.some((m) => m.role === 'system');\n  const systemPrompt = hasSystemMessage\n    ? '' // Native will extract from messages\n    : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;\n\n  const promise = new Promise<LLMResponse>((resolve, reject) => {\n    // Subscribe to stream events\n    const subscription = ExpoAiKitModule.addListener(\n      'onStreamToken',\n      (event: LLMStreamEvent) => {\n        // Only process events for this session\n        if (event.sessionId !== sessionId) return;\n\n        finalText = event.accumulatedText;\n\n        // Call the user's callback\n        onToken(event);\n\n        // If done, clean up and resolve\n        if (event.isDone) {\n          subscription.remove();\n          resolve({ text: finalText });\n        }\n      }\n    );\n\n    // Start streaming on native side\n    ExpoAiKitModule.startStreaming(messages, systemPrompt, sessionId).catch(\n      (error) => {\n        subscription.remove();\n        reject(error);\n      }\n    );\n  });\n\n  const stop = () => {\n    if (stopped) return;\n    stopped = true;\n    ExpoAiKitModule.stopStreaming(sessionId).catch(() => {\n      // Ignore errors when stopping\n    });\n  };\n\n  return { promise, stop };\n}\n\n"]}

package/build/types.d.ts

@@ -26,4 +26,31 @@ export type LLMResponse = {
     /** The generated response text */
     text: string;
 };
+/**
+ * Options for streamMessage.
+ */
+export type LLMStreamOptions = {
+    /**
+     * Default system prompt to use if no system message is provided in the messages array.
+     * If a system message exists in the array, this is ignored.
+     */
+    systemPrompt?: string;
+};
+/**
+ * Event payload for streaming tokens.
+ */
+export type LLMStreamEvent = {
+    /** Unique identifier for this streaming session */
+    sessionId: string;
+    /** The token/chunk of text received */
+    token: string;
+    /** Accumulated text so far */
+    accumulatedText: string;
+    /** Whether this is the final chunk */
+    isDone: boolean;
+};
+/**
+ * Callback function for streaming events.
+ */
+export type LLMStreamCallback = (event: LLMStreamEvent) => void;
 //# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC"}

package/build/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Role in a conversation message.\n */\nexport type LLMRole = 'system' | 'user' | 'assistant';\n\n/**\n * A single message in a conversation.\n */\nexport type LLMMessage = {\n  role: LLMRole;\n  content: string;\n};\n\n/**\n * Options for sendMessage.\n */\nexport type LLMSendOptions = {\n  /**\n   * Default system prompt to use if no system message is provided in the messages array.\n   * If a system message exists in the array, this is ignored.\n   */\n  systemPrompt?: string;\n};\n\n/**\n * Response from sendMessage.\n */\nexport type LLMResponse = {\n  /** The generated response text */\n  text: string;\n};\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Role in a conversation message.\n */\nexport type LLMRole = 'system' | 'user' | 'assistant';\n\n/**\n * A single message in a conversation.\n */\nexport type LLMMessage = {\n  role: LLMRole;\n  content: string;\n};\n\n/**\n * Options for sendMessage.\n */\nexport type LLMSendOptions = {\n  /**\n   * Default system prompt to use if no system message is provided in the messages array.\n   * If a system message exists in the array, this is ignored.\n   */\n  systemPrompt?: string;\n};\n\n/**\n * Response from sendMessage.\n */\nexport type LLMResponse = {\n  /** The generated response text */\n  text: string;\n};\n\n/**\n * Options for streamMessage.\n */\nexport type LLMStreamOptions = {\n  /**\n   * Default system prompt to use if no system message is provided in the messages array.\n   * If a system message exists in the array, this is ignored.\n   */\n  systemPrompt?: string;\n};\n\n/**\n * Event payload for streaming tokens.\n */\nexport type LLMStreamEvent = {\n  /** Unique identifier for this streaming session */\n  sessionId: string;\n  /** The token/chunk of text received */\n  token: string;\n  /** Accumulated text so far */\n  accumulatedText: string;\n  /** Whether this is the final chunk */\n  isDone: boolean;\n};\n\n/**\n * Callback function for streaming events.\n */\nexport type LLMStreamCallback = (event: LLMStreamEvent) => void;\n"]}

package/ios/ExpoAiKitModule.swift

@@ -2,9 +2,15 @@ import ExpoModulesCore
 import FoundationModels
 
 public class ExpoAiKitModule: Module {
+  // Track active streaming tasks for cancellation
+  private var activeStreamTasks: [String: Task<Void, Never>] = [:]
+
   public func definition() -> ModuleDefinition {
     Name("ExpoAiKit")
 
+    // Declare events that can be sent to JavaScript
+    Events("onStreamToken")
+
     Function("isAvailable") {
       if #available(iOS 26.0, *) {
         return true
@@ -42,5 +48,94 @@ public class ExpoAiKitModule: Module {
         return ["text": "[On-device AI requires iOS 26+]"]
       }
     }
+
+    AsyncFunction("startStreaming") {
+      (
+        messages: [[String: Any]],
+        fallbackSystemPrompt: String,
+        sessionId: String
+      ) in
+
+      // Extract system prompt from messages, or use fallback
+      let systemPrompt =
+        messages
+        .first { ($0["role"] as? String) == "system" }?["content"] as? String
+        ?? (fallbackSystemPrompt.isEmpty
+          ? "You are a helpful, friendly assistant."
+          : fallbackSystemPrompt)
+
+      // Get the last user message as the prompt
+      let userPrompt =
+        messages
+        .reversed()
+        .first { ($0["role"] as? String) == "user" }?["content"] as? String
+        ?? ""
+
+      if #available(iOS 26.0, *) {
+        // Create a task for streaming that can be cancelled
+        let task = Task {
+          do {
+            let session = LanguageModelSession(instructions: systemPrompt)
+            let stream = session.streamResponse(to: userPrompt)
+            var accumulatedText = ""
+
+            for try await partialResponse in stream {
+              // Check for cancellation
+              if Task.isCancelled { break }
+
+              let currentText = partialResponse.content
+              let newToken = String(currentText.dropFirst(accumulatedText.count))
+              accumulatedText = currentText
+
+              // Send token event to JavaScript
+              self.sendEvent("onStreamToken", [
+                "sessionId": sessionId,
+                "token": newToken,
+                "accumulatedText": accumulatedText,
+                "isDone": false
+              ])
+            }
+
+            // Send final event
+            if !Task.isCancelled {
+              self.sendEvent("onStreamToken", [
+                "sessionId": sessionId,
+                "token": "",
+                "accumulatedText": accumulatedText,
+                "isDone": true
+              ])
+            }
+          } catch {
+            // Send error as final event
+            self.sendEvent("onStreamToken", [
+              "sessionId": sessionId,
+              "token": "",
+              "accumulatedText": "[Error: \(error.localizedDescription)]",
+              "isDone": true
+            ])
+          }
+
+          // Clean up
+          self.activeStreamTasks.removeValue(forKey: sessionId)
+        }
+
+        self.activeStreamTasks[sessionId] = task
+      } else {
+        // Fallback for older iOS versions - send single response
+        self.sendEvent("onStreamToken", [
+          "sessionId": sessionId,
+          "token": "[On-device AI requires iOS 26+]",
+          "accumulatedText": "[On-device AI requires iOS 26+]",
+          "isDone": true
+        ])
+      }
+    }
+
+    AsyncFunction("stopStreaming") { (sessionId: String) in
+      if let task = self.activeStreamTasks[sessionId] {
+        task.cancel()
+        self.activeStreamTasks.removeValue(forKey: sessionId)
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-ai-kit",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Expo AI Kit module",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/src/ExpoAiKitModule.ts

@@ -1,15 +1,30 @@
 import { requireNativeModule } from 'expo-modules-core';
-import { LLMMessage, LLMResponse } from './types';
+import type { EventSubscription } from 'expo-modules-core';
+import { LLMMessage, LLMResponse, LLMStreamEvent } from './types';
 
-export type ExpoAiKitNativeModule = {
+export type ExpoAiKitModuleEvents = {
+  onStreamToken: (event: LLMStreamEvent) => void;
+};
+
+export interface ExpoAiKitNativeModule {
   isAvailable(): boolean;
   sendMessage(
     messages: LLMMessage[],
     systemPrompt: string
   ): Promise<LLMResponse>;
-};
+  startStreaming(
+    messages: LLMMessage[],
+    systemPrompt: string,
+    sessionId: string
+  ): Promise<void>;
+  stopStreaming(sessionId: string): Promise<void>;
+  addListener<K extends keyof ExpoAiKitModuleEvents>(
+    eventName: K,
+    listener: ExpoAiKitModuleEvents[K]
+  ): EventSubscription;
+}
 
-const NativeModule: ExpoAiKitNativeModule =
+const ExpoAiKitModule =
   requireNativeModule<ExpoAiKitNativeModule>('ExpoAiKit');
 
-export default NativeModule;
+export default ExpoAiKitModule;

package/src/__tests__/index.test.js

@@ -9,22 +9,47 @@ jest.mock('react-native', () => ({
   },
 }));
 
+// Store event listeners for testing - must be prefixed with 'mock' for jest
+let mockEventListeners = {};
+
 // Mock the native module
 jest.mock('../ExpoAiKitModule', () => ({
   __esModule: true,
   default: {
     isAvailable: jest.fn(() => true),
     sendMessage: jest.fn(() => Promise.resolve({ text: 'Mock response' })),
+    startStreaming: jest.fn(() => Promise.resolve()),
+    stopStreaming: jest.fn(() => Promise.resolve()),
+    addListener: jest.fn((eventName, callback) => {
+      if (!mockEventListeners[eventName]) {
+        mockEventListeners[eventName] = [];
+      }
+      mockEventListeners[eventName].push(callback);
+      return {
+        remove: () => {
+          mockEventListeners[eventName] = mockEventListeners[eventName].filter(
+            (cb) => cb !== callback
+          );
+        },
+      };
+    }),
   },
 }));
 
-const { isAvailable, sendMessage } = require('../index');
+// Helper to simulate native events
+const simulateStreamEvent = (event) => {
+  const listeners = mockEventListeners['onStreamToken'] || [];
+  listeners.forEach((cb) => cb(event));
+};
+
+const { isAvailable, sendMessage, streamMessage } = require('../index');
 const NativeModule = require('../ExpoAiKitModule').default;
 
 describe('expo-ai-kit', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     mockPlatformOS = 'ios';
+    mockEventListeners = {};
   });
 
   describe('isAvailable', () => {
@@ -121,4 +146,152 @@ describe('expo-ai-kit', () => {
       ).resolves.not.toThrow();
     });
   });
+
+  describe('streamMessage', () => {
+    it('returns promise and stop function', () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      const result = streamMessage(messages, onToken);
+
+      expect(result).toHaveProperty('promise');
+      expect(result).toHaveProperty('stop');
+      expect(typeof result.stop).toBe('function');
+    });
+
+    it('calls native startStreaming with correct arguments', () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      streamMessage(messages, onToken);
+
+      expect(NativeModule.startStreaming).toHaveBeenCalledWith(
+        messages,
+        'You are a helpful, friendly assistant. Answer the user directly and concisely.',
+        expect.stringMatching(/^stream_\d+_\d+$/)
+      );
+    });
+
+    it('uses custom system prompt from options', () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      streamMessage(messages, onToken, { systemPrompt: 'Be a pirate.' });
+
+      expect(NativeModule.startStreaming).toHaveBeenCalledWith(
+        messages,
+        'Be a pirate.',
+        expect.any(String)
+      );
+    });
+
+    it('passes empty string when messages contain system message', () => {
+      const messages = [
+        { role: 'system', content: 'Be brief.' },
+        { role: 'user', content: 'Hello' },
+      ];
+      const onToken = jest.fn();
+
+      streamMessage(messages, onToken, { systemPrompt: 'This should be ignored' });
+
+      expect(NativeModule.startStreaming).toHaveBeenCalledWith(
+        messages,
+        '',
+        expect.any(String)
+      );
+    });
+
+    it('calls onToken callback for each stream event', async () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      const { promise } = streamMessage(messages, onToken);
+
+      // Get the sessionId that was used
+      const sessionId = NativeModule.startStreaming.mock.calls[0][2];
+
+      // Simulate streaming events
+      simulateStreamEvent({
+        sessionId,
+        token: 'Hello',
+        accumulatedText: 'Hello',
+        isDone: false,
+      });
+
+      simulateStreamEvent({
+        sessionId,
+        token: ' world',
+        accumulatedText: 'Hello world',
+        isDone: false,
+      });
+
+      simulateStreamEvent({
+        sessionId,
+        token: '',
+        accumulatedText: 'Hello world',
+        isDone: true,
+      });
+
+      const result = await promise;
+
+      expect(onToken).toHaveBeenCalledTimes(3);
+      expect(onToken).toHaveBeenNthCalledWith(1, {
+        sessionId,
+        token: 'Hello',
+        accumulatedText: 'Hello',
+        isDone: false,
+      });
+      expect(result).toEqual({ text: 'Hello world' });
+    });
+
+    it('ignores events from other sessions', () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      streamMessage(messages, onToken);
+
+      // Simulate event from different session
+      simulateStreamEvent({
+        sessionId: 'other_session',
+        token: 'Other',
+        accumulatedText: 'Other',
+        isDone: false,
+      });
+
+      expect(onToken).not.toHaveBeenCalled();
+    });
+
+    it('calls stopStreaming when stop() is called', () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      const { stop } = streamMessage(messages, onToken);
+      const sessionId = NativeModule.startStreaming.mock.calls[0][2];
+
+      stop();
+
+      expect(NativeModule.stopStreaming).toHaveBeenCalledWith(sessionId);
+    });
+
+    it('returns empty response on unsupported platforms', () => {
+      mockPlatformOS = 'web';
+
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const onToken = jest.fn();
+
+      const { promise, stop } = streamMessage(messages, onToken);
+
+      expect(NativeModule.startStreaming).not.toHaveBeenCalled();
+      expect(promise).resolves.toEqual({ text: '' });
+      expect(stop).toBeDefined();
+    });
+
+    it('rejects promise for empty messages array', () => {
+      const onToken = jest.fn();
+
+      const { promise } = streamMessage([], onToken);
+
+      expect(promise).rejects.toThrow('messages array cannot be empty');
+    });
+  });
 });

package/src/index.ts

@@ -1,12 +1,24 @@
-import NativeModule from './ExpoAiKitModule';
+import ExpoAiKitModule from './ExpoAiKitModule';
 import { Platform } from 'react-native';
-import { LLMMessage, LLMSendOptions, LLMResponse } from './types';
+import {
+  LLMMessage,
+  LLMSendOptions,
+  LLMResponse,
+  LLMStreamOptions,
+  LLMStreamEvent,
+  LLMStreamCallback,
+} from './types';
 
 export * from './types';
 
 const DEFAULT_SYSTEM_PROMPT =
   'You are a helpful, friendly assistant. Answer the user directly and concisely.';
 
+let streamIdCounter = 0;
+function generateSessionId(): string {
+  return `stream_${Date.now()}_${++streamIdCounter}`;
+}
+
 /**
  * Check if on-device AI is available on the current device.
  * Returns false on unsupported platforms (web, etc.).
@@ -15,7 +27,7 @@ export async function isAvailable(): Promise<boolean> {
   if (Platform.OS !== 'ios' && Platform.OS !== 'android') {
     return false;
   }
-  return NativeModule.isAvailable();
+  return ExpoAiKitModule.isAvailable();
 }
 
 /**
@@ -71,6 +83,121 @@ export async function sendMessage(
     ? '' // Native will extract from messages
     : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
 
-  return NativeModule.sendMessage(messages, systemPrompt);
+  return ExpoAiKitModule.sendMessage(messages, systemPrompt);
+}
+
+/**
+ * Stream messages to the on-device LLM and receive progressive token updates.
+ *
+ * @param messages - Array of messages representing the conversation
+ * @param onToken - Callback function called for each token/chunk received
+ * @param options - Optional settings (systemPrompt fallback)
+ * @returns Object with stop() function to cancel streaming and promise that resolves when complete
+ *
+ * @example
+ * ```ts
+ * // Basic streaming
+ * const { promise } = streamMessage(
+ *   [{ role: 'user', content: 'Tell me a story' }],
+ *   (event) => {
+ *     console.log(event.token); // Each token as it arrives
+ *     console.log(event.accumulatedText); // Full text so far
+ *   }
+ * );
+ * await promise;
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cancellation
+ * const { promise, stop } = streamMessage(
+ *   [{ role: 'user', content: 'Write a long essay' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ *
+ * // Cancel after 5 seconds
+ * setTimeout(() => stop(), 5000);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // React state update pattern
+ * const [text, setText] = useState('');
+ *
+ * streamMessage(
+ *   [{ role: 'user', content: 'Hello!' }],
+ *   (event) => setText(event.accumulatedText)
+ * );
+ * ```
+ */
+export function streamMessage(
+  messages: LLMMessage[],
+  onToken: LLMStreamCallback,
+  options?: LLMStreamOptions
+): { promise: Promise<LLMResponse>; stop: () => void } {
+  // Handle unsupported platforms
+  if (Platform.OS !== 'ios' && Platform.OS !== 'android') {
+    return {
+      promise: Promise.resolve({ text: '' }),
+      stop: () => {},
+    };
+  }
+
+  if (!messages || messages.length === 0) {
+    return {
+      promise: Promise.reject(new Error('messages array cannot be empty')),
+      stop: () => {},
+    };
+  }
+
+  const sessionId = generateSessionId();
+  let finalText = '';
+  let stopped = false;
+
+  // Determine system prompt: use from messages array if present, else options, else default
+  const hasSystemMessage = messages.some((m) => m.role === 'system');
+  const systemPrompt = hasSystemMessage
+    ? '' // Native will extract from messages
+    : options?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+
+  const promise = new Promise<LLMResponse>((resolve, reject) => {
+    // Subscribe to stream events
+    const subscription = ExpoAiKitModule.addListener(
+      'onStreamToken',
+      (event: LLMStreamEvent) => {
+        // Only process events for this session
+        if (event.sessionId !== sessionId) return;
+
+        finalText = event.accumulatedText;
+
+        // Call the user's callback
+        onToken(event);
+
+        // If done, clean up and resolve
+        if (event.isDone) {
+          subscription.remove();
+          resolve({ text: finalText });
+        }
+      }
+    );
+
+    // Start streaming on native side
+    ExpoAiKitModule.startStreaming(messages, systemPrompt, sessionId).catch(
+      (error) => {
+        subscription.remove();
+        reject(error);
+      }
+    );
+  });
+
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    ExpoAiKitModule.stopStreaming(sessionId).catch(() => {
+      // Ignore errors when stopping
+    });
+  };
+
+  return { promise, stop };
 }
 

package/src/types.ts

@@ -29,3 +29,33 @@ export type LLMResponse = {
   /** The generated response text */
   text: string;
 };
+
+/**
+ * Options for streamMessage.
+ */
+export type LLMStreamOptions = {
+  /**
+   * Default system prompt to use if no system message is provided in the messages array.
+   * If a system message exists in the array, this is ignored.
+   */
+  systemPrompt?: string;
+};
+
+/**
+ * Event payload for streaming tokens.
+ */
+export type LLMStreamEvent = {
+  /** Unique identifier for this streaming session */
+  sessionId: string;
+  /** The token/chunk of text received */
+  token: string;
+  /** Accumulated text so far */
+  accumulatedText: string;
+  /** Whether this is the final chunk */
+  isDone: boolean;
+};
+
+/**
+ * Callback function for streaming events.
+ */
+export type LLMStreamCallback = (event: LLMStreamEvent) => void;