react-native-nobodywho 1.1.0 → 2.0.0

package/Nobodywho.podspec

@@ -10,7 +10,7 @@ framework_name = "NobodywhoFramework.xcframework"
 framework_dir = File.join(__dir__, framework_name)
 zip_name = "#{framework_name}.zip"
 zip_path = File.join(__dir__, zip_name)
-url = "https://github.com/nobodywho-ooo/nobodywho/releases/download/nobodywho-react-native-#{version}/#{zip_name}"
+url = "https://github.com/nobodywho-ooo/nobodywho/releases/download/nobodywho-react-native-v#{version}/#{zip_name}"
 
 # Always download a fresh xcframework to ensure it matches the package version.
 FileUtils.rm_rf(framework_dir) if File.exist?(framework_dir)
@@ -20,7 +20,7 @@ puts "[NobodyWho] Downloading xcframework from #{url}"
 system("curl", "-L", "-f", "-o", zip_path, url) or
   raise "Failed to download NobodyWho xcframework.\n" \
         "URL: #{url}\n" \
-        "Check that the release exists: https://github.com/nobodywho-ooo/nobodywho/releases/tag/nobodywho-react-native-#{version}\n" \
+        "Check that the release exists: https://github.com/nobodywho-ooo/nobodywho/releases/tag/nobodywho-react-native-v#{version}\n" \
         "For local development, manually place the xcframework at: #{framework_dir}"
 
 puts "[NobodyWho] Extracting xcframework..."

package/generated/ts/nobodywho.ts

@@ -619,38 +619,39 @@ const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
 // Enum: Message
 export enum Message_Tags {
-    Message = "Message",
-    ToolCalls = "ToolCalls",
-    ToolResp = "ToolResp"
+    User = "User",
+    Assistant = "Assistant",
+    System = "System",
+    Tool = "Tool"
 }
 export const Message = (() => {
     
 
-    type Message__interface = {
-        tag: Message_Tags.Message;
-        inner: Readonly<{role: Role; content: string; assets: Array<Asset>}>
+    type User__interface = {
+        tag: Message_Tags.User;
+        inner: Readonly<{content: string; assets: Array<Asset>}>
     };
 
     
-    class Message_ extends UniffiEnum implements Message__interface {
+    class User_ extends UniffiEnum implements User__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.Message;
-        readonly inner: Readonly<{role: Role; content: string; assets: Array<Asset>}>;
-        constructor(inner: { role: Role, content: string, assets: Array<Asset> }) {
-            super("Message", "Message");
+        readonly tag = Message_Tags.User;
+        readonly inner: Readonly<{content: string; assets: Array<Asset>}>;
+        constructor(inner: { content: string, assets: Array<Asset> }) {
+            super("Message", "User");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, content: string, assets: Array<Asset> }): Message_ {
-            return new Message_(inner);
+        static new(inner: { content: string, assets: Array<Asset> }): User_ {
+            return new User_(inner);
         }
 
-        static instanceOf(obj: any): obj is Message_ {
-            return obj.tag === Message_Tags.Message;
+        static instanceOf(obj: any): obj is User_ {
+            return obj.tag === Message_Tags.User;
         }
         
 
@@ -659,31 +660,31 @@ export const Message = (() => {
     }
     
 
-    type ToolCalls__interface = {
-        tag: Message_Tags.ToolCalls;
-        inner: Readonly<{role: Role; content: string; toolCalls: Array<ToolCall>}>
+    type Assistant__interface = {
+        tag: Message_Tags.Assistant;
+        inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>
     };
 
     
-    class ToolCalls_ extends UniffiEnum implements ToolCalls__interface {
+    class Assistant_ extends UniffiEnum implements Assistant__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.ToolCalls;
-        readonly inner: Readonly<{role: Role; content: string; toolCalls: Array<ToolCall>}>;
-        constructor(inner: { role: Role, content: string, toolCalls: Array<ToolCall> }) {
-            super("Message", "ToolCalls");
+        readonly tag = Message_Tags.Assistant;
+        readonly inner: Readonly<{content: string; toolCalls: Array<ToolCall> | undefined}>;
+        constructor(inner: { content: string, toolCalls: Array<ToolCall> | undefined }) {
+            super("Message", "Assistant");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, content: string, toolCalls: Array<ToolCall> }): ToolCalls_ {
-            return new ToolCalls_(inner);
+        static new(inner: { content: string, toolCalls: Array<ToolCall> | undefined }): Assistant_ {
+            return new Assistant_(inner);
         }
 
-        static instanceOf(obj: any): obj is ToolCalls_ {
-            return obj.tag === Message_Tags.ToolCalls;
+        static instanceOf(obj: any): obj is Assistant_ {
+            return obj.tag === Message_Tags.Assistant;
         }
         
 
@@ -692,31 +693,64 @@ export const Message = (() => {
     }
     
 
-    type ToolResp__interface = {
-        tag: Message_Tags.ToolResp;
-        inner: Readonly<{role: Role; name: string; content: string}>
+    type System__interface = {
+        tag: Message_Tags.System;
+        inner: Readonly<{content: string}>
+    };
+
+    
+    class System_ extends UniffiEnum implements System__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "Message";
+        readonly tag = Message_Tags.System;
+        readonly inner: Readonly<{content: string}>;
+        constructor(inner: { content: string }) {
+            super("Message", "System");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { content: string }): System_ {
+            return new System_(inner);
+        }
+
+        static instanceOf(obj: any): obj is System_ {
+            return obj.tag === Message_Tags.System;
+        }
+        
+
+        
+
+    }
+    
+
+    type Tool__interface = {
+        tag: Message_Tags.Tool;
+        inner: Readonly<{name: string; content: string}>
     };
 
     
-    class ToolResp_ extends UniffiEnum implements ToolResp__interface {
+    class Tool_ extends UniffiEnum implements Tool__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
         readonly [uniffiTypeNameSymbol] = "Message";
-        readonly tag = Message_Tags.ToolResp;
-        readonly inner: Readonly<{role: Role; name: string; content: string}>;
-        constructor(inner: { role: Role, name: string, content: string }) {
-            super("Message", "ToolResp");
+        readonly tag = Message_Tags.Tool;
+        readonly inner: Readonly<{name: string; content: string}>;
+        constructor(inner: { name: string, content: string }) {
+            super("Message", "Tool");
             this.inner = Object.freeze(inner);
         }
 
-        static new(inner: { role: Role, name: string, content: string }): ToolResp_ {
-            return new ToolResp_(inner);
+        static new(inner: { name: string, content: string }): Tool_ {
+            return new Tool_(inner);
         }
 
-        static instanceOf(obj: any): obj is ToolResp_ {
-            return obj.tag === Message_Tags.ToolResp;
+        static instanceOf(obj: any): obj is Tool_ {
+            return obj.tag === Message_Tags.Tool;
         }
         
 
@@ -730,9 +764,10 @@ export const Message = (() => {
 
     return Object.freeze({
         instanceOf,
-  Message: Message_, 
-  ToolCalls: ToolCalls_, 
-  ToolResp: ToolResp_
+  User: User_, 
+  Assistant: Assistant_, 
+  System: System_, 
+  Tool: Tool_
     });
 
 })();
@@ -750,34 +785,38 @@ const FfiConverterTypeMessage = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         read(from: RustBuffer): TypeName {
             switch (ordinalConverter.read(from)) {
-                case 1: return new Message.Message({role: FfiConverterTypeRole.read(from), content: FfiConverterString.read(from), assets: FfiConverterArrayTypeAsset.read(from) });
-                case 2: return new Message.ToolCalls({role: FfiConverterTypeRole.read(from), content: FfiConverterString.read(from), toolCalls: FfiConverterArrayTypeToolCall.read(from) });
-                case 3: return new Message.ToolResp({role: FfiConverterTypeRole.read(from), name: FfiConverterString.read(from), content: FfiConverterString.read(from) });
+                case 1: return new Message.User({content: FfiConverterString.read(from), assets: FfiConverterArrayTypeAsset.read(from) });
+                case 2: return new Message.Assistant({content: FfiConverterString.read(from), toolCalls: FfiConverterOptionalArrayTypeToolCall.read(from) });
+                case 3: return new Message.System({content: FfiConverterString.read(from) });
+                case 4: return new Message.Tool({name: FfiConverterString.read(from), content: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         write(value: TypeName, into: RustBuffer): void {
             switch (value.tag) {
-                case Message_Tags.Message: {
+                case Message_Tags.User: {
                     ordinalConverter.write(1, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
                     FfiConverterString.write(inner.content, into);
                     FfiConverterArrayTypeAsset.write(inner.assets, into);
                     return;
                 }
-                case Message_Tags.ToolCalls: {
+                case Message_Tags.Assistant: {
                     ordinalConverter.write(2, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
                     FfiConverterString.write(inner.content, into);
-                    FfiConverterArrayTypeToolCall.write(inner.toolCalls, into);
+                    FfiConverterOptionalArrayTypeToolCall.write(inner.toolCalls, into);
                     return;
                 }
-                case Message_Tags.ToolResp: {
+                case Message_Tags.System: {
                     ordinalConverter.write(3, into);
                     const inner = value.inner;
-                    FfiConverterTypeRole.write(inner.role, into);
+                    FfiConverterString.write(inner.content, into);
+                    return;
+                }
+                case Message_Tags.Tool: {
+                    ordinalConverter.write(4, into);
+                    const inner = value.inner;
                     FfiConverterString.write(inner.name, into);
                     FfiConverterString.write(inner.content, into);
                     return;
@@ -789,26 +828,29 @@ const FfiConverterTypeMessage = (() => {
         }
         allocationSize(value: TypeName): number {
             switch (value.tag) {
-                case Message_Tags.Message: {
+                case Message_Tags.User: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(1);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
                     size += FfiConverterString.allocationSize(inner.content);
                     size += FfiConverterArrayTypeAsset.allocationSize(inner.assets);
                     return size;
                 }
-                case Message_Tags.ToolCalls: {
+                case Message_Tags.Assistant: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(2);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
                     size += FfiConverterString.allocationSize(inner.content);
-                    size += FfiConverterArrayTypeToolCall.allocationSize(inner.toolCalls);
+                    size += FfiConverterOptionalArrayTypeToolCall.allocationSize(inner.toolCalls);
                     return size;
                 }
-                case Message_Tags.ToolResp: {
+                case Message_Tags.System: {
                     const inner = value.inner;
                     let size = ordinalConverter.allocationSize(3);
-                    size += FfiConverterTypeRole.allocationSize(inner.role);
+                    size += FfiConverterString.allocationSize(inner.content);
+                    return size;
+                }
+                case Message_Tags.Tool: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
                     size += FfiConverterString.allocationSize(inner.name);
                     size += FfiConverterString.allocationSize(inner.content);
                     return size;
@@ -1094,45 +1136,6 @@ const FfiConverterTypePromptPart = (() => {
 
 
 
-export enum Role {
-    User,
-    Assistant,
-    System,
-    Tool
-}
-
-const FfiConverterTypeRole = (() => {
-    const ordinalConverter = FfiConverterInt32;
-    type TypeName = Role;
-    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-        read(from: RustBuffer): TypeName {
-            switch (ordinalConverter.read(from)) {
-                case 1: return Role.User;
-                case 2: return Role.Assistant;
-                case 3: return Role.System;
-                case 4: return Role.Tool;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        write(value: TypeName, into: RustBuffer): void {
-            switch (value) {
-                case Role.User: return ordinalConverter.write(1, into);
-                case Role.Assistant: return ordinalConverter.write(2, into);
-                case Role.System: return ordinalConverter.write(3, into);
-                case Role.Tool: return ordinalConverter.write(4, into);
-            }
-        }
-        allocationSize(value: TypeName): number {
-            return ordinalConverter.allocationSize(0);
-        }
-    }
-    return new FFIConverter();
-})();
-
-
-
-
-
 // FfiConverter for Map<string, boolean>
 const FfiConverterMapStringBool = new FfiConverterMap(FfiConverterString, FfiConverterBool);
 
@@ -2999,6 +3002,10 @@ const FfiConverterOptionalMapStringBool = new FfiConverterOptional(FfiConverterM
 const FfiConverterOptionalTypeSamplerConfig = new FfiConverterOptional(FfiConverterTypeSamplerConfig);
 
 
+// FfiConverter for Array<ToolCall> | undefined
+const FfiConverterOptionalArrayTypeToolCall = new FfiConverterOptional(FfiConverterArrayTypeToolCall);
+
+
 // FfiConverter for Array<Message>
 const FfiConverterArrayTypeMessage = new FfiConverterArray(FfiConverterTypeMessage);
 
@@ -3210,7 +3217,6 @@ export default Object.freeze({
     FfiConverterTypeNobodyWhoError,
     FfiConverterTypePendingToolCall,
     FfiConverterTypePromptPart,
-    FfiConverterTypeRole,
     FfiConverterTypeRustChat,
     FfiConverterTypeRustCrossEncoder,
     FfiConverterTypeRustEncoder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",

package/src/chat.ts

@@ -3,7 +3,7 @@ import {
   SamplerConfig,
 } from "../generated/ts/nobodywho";
 import { Model } from "./model";
-import { type ChatMessage, fromInternal, toInternal } from "./message";
+import { type Message, fromInternal, toInternal } from "./message";
 import { TokenStream } from "./streaming";
 import type { Prompt } from "./prompt";
 import type { Tool } from "./tool";
@@ -110,13 +110,13 @@ export class Chat {
   }
 
   /** Get the current chat history as a list of messages. */
-  async getChatHistory(): Promise<ChatMessage[]> {
+  async getChatHistory(): Promise<Message[]> {
     const internal = await this._inner.getChatHistory();
     return internal.map(fromInternal);
   }
 
   /** Set the chat history from a list of messages. */
-  async setChatHistory(messages: ChatMessage[]): Promise<void> {
+  async setChatHistory(messages: Message[]): Promise<void> {
     return this._inner.setChatHistory(messages.map(toInternal));
   }
 

package/src/message.ts

@@ -1,75 +1,89 @@
 import {
   Message as InternalMessage,
   Message_Tags,
-  Role,
   type Asset,
   type ToolCall,
 } from "../generated/ts/nobodywho";
 
 /**
- * A chat message. The `role` field combined with the presence of
- * `toolCalls` or `name` determines the message type:
+ * A chat message. The variant determines the message type:
  *
- * - **User/Assistant/System message:** `{ role, content, assets? }`
- * - **Tool call request:** `{ role: Role.Assistant, content, toolCalls }`
- * - **Tool response:** `{ role: Role.Tool, name, content }`
+ * - **User message:** `{ role: "user", content, assets? }`
+ * - **Assistant message:** `{ role: "assistant", content }`
+ * - **Assistant tool call:** `{ role: "assistant", content, toolCalls }`
+ * - **System message:** `{ role: "system", content }`
+ * - **Tool response:** `{ role: "tool", name, content }`
  *
  * @example
  * ```typescript
  * const history = await chat.getChatHistory();
  * for (const msg of history) {
- *   if ("toolCalls" in msg) {
- *     console.log("Tool calls:", msg.toolCalls);
- *   } else if ("name" in msg) {
+ *   if (msg.role === "tool") {
  *     console.log("Tool response:", msg.name, msg.content);
+ *   } else if (msg.role === "assistant" && "toolCalls" in msg) {
+ *     console.log("Tool calls:", msg.toolCalls);
  *   } else {
  *     console.log(msg.role, msg.content);
  *   }
  * }
  * ```
  */
-export type ChatMessage =
-  | { role: Role.User | Role.Assistant | Role.System; content: string; assets?: Asset[] }
-  | { role: Role.Assistant; content: string; toolCalls: ToolCall[] }
-  | { role: Role.Tool; name: string; content: string };
+export type Message =
+  | { role: "user"; content: string; assets?: Asset[] }
+  | { role: "assistant"; content: string }
+  | { role: "assistant"; content: string; toolCalls: ToolCall[] }
+  | { role: "system"; content: string }
+  | { role: "tool"; name: string; content: string };
 
-/** @internal Convert internal Message to ChatMessage */
-export function fromInternal(msg: InternalMessage): ChatMessage {
-  if (msg.tag === Message_Tags.Message) {
-    const { role, content, assets } = msg.inner;
+/** @internal Convert internal Message to Message */
+export function fromInternal(msg: InternalMessage): Message {
+  if (msg.tag === Message_Tags.User) {
+    const { content, assets } = msg.inner;
     return {
-      role: role as Role.User | Role.Assistant | Role.System,
+      role: "user",
       content,
       ...(assets.length > 0 ? { assets } : {}),
     };
-  } else if (msg.tag === Message_Tags.ToolCalls) {
-    const { role, content, toolCalls } = msg.inner;
-    return { role: role as Role.Assistant, content, toolCalls };
+  } else if (msg.tag === Message_Tags.Assistant) {
+    const { content, toolCalls } = msg.inner;
+    if (toolCalls != null && toolCalls.length > 0) {
+      return { role: "assistant", content, toolCalls };
+    }
+    return { role: "assistant", content };
+  } else if (msg.tag === Message_Tags.System) {
+    const { content } = msg.inner;
+    return { role: "system", content };
   } else {
-    const { role, name, content } = msg.inner;
-    return { role: role as Role.Tool, name, content };
+    const { name, content } = msg.inner;
+    return { role: "tool", name, content };
   }
 }
 
-/** @internal Convert ChatMessage to internal Message */
-export function toInternal(msg: ChatMessage): InternalMessage {
-  if ("toolCalls" in msg) {
-    return new InternalMessage.ToolCalls({
-      role: msg.role,
+/** @internal Convert Message to internal Message */
+export function toInternal(msg: Message): InternalMessage {
+  if (msg.role === "user") {
+    return new InternalMessage.User({
+      content: msg.content,
+      assets: msg.assets ?? [],
+    });
+  } else if (msg.role === "assistant" && "toolCalls" in msg) {
+    return new InternalMessage.Assistant({
       content: msg.content,
       toolCalls: msg.toolCalls,
     });
-  } else if ("name" in msg) {
-    return new InternalMessage.ToolResp({
-      role: msg.role,
-      name: msg.name,
+  } else if (msg.role === "assistant") {
+    return new InternalMessage.Assistant({
+      content: msg.content,
+      toolCalls: null,
+    });
+  } else if (msg.role === "system") {
+    return new InternalMessage.System({
       content: msg.content,
     });
   } else {
-    return new InternalMessage.Message({
-      role: msg.role,
+    return new InternalMessage.Tool({
+      name: msg.name,
       content: msg.content,
-      assets: msg.assets ?? [],
     });
   }
 }

package/src/wrapper.ts

@@ -3,8 +3,8 @@
  *
  * This is the public entry point. It re-exports the public API:
  * - Wrapper classes: Model, Chat, Encoder, CrossEncoder, Tool, TokenStream, Prompt
- * - Direct re-exports: SamplerBuilder, SamplerConfig, Role
- * - Types: ChatMessage, Asset, ToolCall
+ * - Direct re-exports: SamplerBuilder, SamplerConfig
+ * - Types: Message, Asset, ToolCall
  * - Utilities: SamplerPresets, cosineSimilarity
  *
  * This file is NOT generated — it is safe to edit.
@@ -20,13 +20,12 @@ export { Tool } from "./tool";
 export { TokenStream } from "./streaming";
 
 // Message types
-export type { ChatMessage } from "./message";
+export type { Message } from "./message";
 
 // Re-export types that don't need wrapping.
 export {
   SamplerBuilder,
   SamplerConfig,
-  Role,
   cosineSimilarity,
 } from "./index";