react-native-nobodywho 0.0.1 → 0.1.0

package/ios/Nobodywho.h

@@ -0,0 +1,16 @@
+// Generated by uniffi-bindgen-react-native
+#ifdef __cplusplus
+#import "react-native-nobodywho.h"
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNNativeModuleSpec.h"
+
+@interface Nobodywho : NSObject <NativeNobodywhoSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface Nobodywho : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/Nobodywho.mm

@@ -0,0 +1,66 @@
+// Generated by uniffi-bindgen-react-native
+#import "Nobodywho.h"
+
+namespace uniffi_generated {
+    using namespace facebook::react;
+    /**
+    * ObjC++ class for module 'NativeNobodywho'
+    */
+    class JSI_EXPORT NativeNobodywhoSpecJSI : public ObjCTurboModule {
+    public:
+        NativeNobodywhoSpecJSI(const ObjCTurboModule::InitParams &params);
+        std::shared_ptr<CallInvoker> callInvoker;
+    };
+
+    static facebook::jsi::Value __hostFunction_Nobodywho_installRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        auto& tm = static_cast<NativeNobodywhoSpecJSI&>(turboModule);
+        auto jsInvoker = tm.callInvoker;
+        uint8_t result = nobodywho::installRustCrate(rt, jsInvoker);
+        return facebook::jsi::Value(rt, result);
+    }
+    static facebook::jsi::Value __hostFunction_Nobodywho_cleanupRustCrate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+        uint8_t result = nobodywho::cleanupRustCrate(rt);
+        return facebook::jsi::Value(rt, result);
+    }
+
+    NativeNobodywhoSpecJSI::NativeNobodywhoSpecJSI(const ObjCTurboModule::InitParams &params)
+        : ObjCTurboModule(params), callInvoker(params.jsInvoker) {
+            this->methodMap_["installRustCrate"] = MethodMetadata {1, __hostFunction_Nobodywho_installRustCrate};
+            this->methodMap_["cleanupRustCrate"] = MethodMetadata {1, __hostFunction_Nobodywho_cleanupRustCrate};
+    }
+} // namespace uniffi_generated
+
+@implementation Nobodywho
+RCT_EXPORT_MODULE()
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// Automated testing checks nobodywho
+// by comparing the whole line here.
+/*
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(nobodywho::multiply(a, b));
+}
+*/
+
+- (NSNumber *)installRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (NSNumber *)cleanupRustCrate {
+    @throw [NSException exceptionWithName:@"UnreachableException"
+                        reason:@"This method should never be called."
+                        userInfo:nil];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<uniffi_generated::NativeNobodywhoSpecJSI>(params);
+}
+#endif
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",
@@ -21,7 +21,16 @@
     "offline"
   ],
   "files": [
-    "README.md"
+    "src/",
+    "generated/",
+    "cpp/",
+    "ios/",
+    "android/",
+    "Nobodywho.podspec",
+    "ubrn.config.yaml",
+    "!android/build",
+    "!android/.cxx",
+    "!android/src/main/jniLibs"
   ],
   "codegenConfig": {
     "name": "NobodywhoSpec",

package/src/NativeNobodywho.ts

@@ -0,0 +1,10 @@
+// Generated by uniffi-bindgen-react-native
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  installRustCrate(): boolean;
+  cleanupRustCrate(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Nobodywho');

package/src/chat.ts

@@ -0,0 +1,155 @@
+import {
+  RustChat,
+  loadModel,
+  type ModelInterface,
+  type SamplerConfigInterface,
+  type Message,
+} from "../generated/ts/nobodywho";
+import { TokenStream } from "./streaming";
+import type { Prompt } from "./prompt";
+import type { Tool } from "./tool";
+
+/**
+ * A chat session for local LLM inference.
+ *
+ * Wraps the internal RustChat with an ergonomic API that uses
+ * the wrapper Tool and TokenStream types.
+ *
+ * @example
+ * ```typescript
+ * const model = await loadModel("model.gguf", true);
+ * const chat = new Chat({
+ *   model,
+ *   systemPrompt: "You are a helpful assistant.",
+ * });
+ * for await (const token of chat.ask("Hello!")) {
+ *   process.stdout.write(token);
+ * }
+ * ```
+ */
+export class Chat {
+  /** @internal */
+  private readonly _inner: RustChat;
+
+  constructor(opts: {
+    model: ModelInterface;
+    systemPrompt?: string;
+    contextSize?: number;
+    templateVariables?: Map<string, boolean>;
+    tools?: Tool[];
+    sampler?: SamplerConfigInterface;
+  }) {
+    this._inner = new RustChat(
+      opts.model,
+      opts.systemPrompt ?? undefined,
+      opts.contextSize ?? 4096,
+      opts.templateVariables ?? undefined,
+      opts.tools?.map((t) => t._inner) ?? undefined,
+      opts.sampler ?? undefined,
+    );
+  }
+
+  /**
+   * Create a chat session directly from a model path.
+   * Loads the model and creates the chat in one step.
+   *
+   * @example
+   * ```typescript
+   * const chat = await Chat.fromPath({
+   *   modelPath: "model.gguf",
+   *   systemPrompt: "You are a helpful assistant.",
+   * });
+   * ```
+   */
+  static async fromPath(opts: {
+    modelPath: string;
+    useGpu?: boolean;
+    imageModelPath?: string;
+    systemPrompt?: string;
+    contextSize?: number;
+    templateVariables?: Map<string, boolean>;
+    tools?: Tool[];
+    sampler?: SamplerConfigInterface;
+  }): Promise<Chat> {
+    const model = await loadModel(
+      opts.modelPath,
+      opts.useGpu ?? true,
+      opts.imageModelPath,
+    );
+    return new Chat({ model, ...opts });
+  }
+
+  /** Send a text message or multimodal prompt and get a token stream for the response. */
+  ask(message: string | Prompt): TokenStream {
+    if (typeof message === "string") {
+      return new TokenStream(this._inner.ask(message));
+    }
+    return new TokenStream(this._inner.askWithPrompt(message._parts));
+  }
+
+  /** Stop the current generation. */
+  stopGeneration(): void {
+    this._inner.stopGeneration();
+  }
+
+  /** Reset the chat context with a new system prompt and tools. */
+  async resetContext(opts?: {
+    systemPrompt?: string;
+    tools?: Tool[];
+  }): Promise<void> {
+    return this._inner.resetContext(
+      opts?.systemPrompt ?? undefined,
+      opts?.tools?.map((t) => t._inner) ?? undefined,
+    );
+  }
+
+  /** Reset the chat history, keeping the system prompt and tools. */
+  async resetHistory(): Promise<void> {
+    return this._inner.resetHistory();
+  }
+
+  /** Get the current chat history as a list of messages. */
+  async getChatHistory(): Promise<Message[]> {
+    return this._inner.getChatHistory();
+  }
+
+  /** Set the chat history from a list of messages. */
+  async setChatHistory(messages: Message[]): Promise<void> {
+    return this._inner.setChatHistory(messages);
+  }
+
+  /** Get the current system prompt. */
+  async getSystemPrompt(): Promise<string | undefined> {
+    return this._inner.getSystemPrompt();
+  }
+
+  /** Set the system prompt. */
+  async setSystemPrompt(systemPrompt: string | undefined): Promise<void> {
+    return this._inner.setSystemPrompt(systemPrompt);
+  }
+
+  /** Set the tools available to the model. */
+  async setTools(tools: Tool[]): Promise<void> {
+    return this._inner.setTools(tools.map((t) => t._inner));
+  }
+
+  /** Set a template variable. */
+  async setTemplateVariable(name: string, value: boolean): Promise<void> {
+    return this._inner.setTemplateVariable(name, value);
+  }
+
+  /** Get all template variables. */
+  async getTemplateVariables(): Promise<Map<string, boolean>> {
+    return this._inner.getTemplateVariables();
+  }
+
+  /** Set the sampler configuration. */
+  async setSamplerConfig(sampler: SamplerConfigInterface): Promise<void> {
+    return this._inner.setSamplerConfig(sampler);
+  }
+
+  /** Get the current sampler configuration as a JSON string. */
+  async getSamplerConfigJson(): Promise<string> {
+    return this._inner.getSamplerConfigJson();
+  }
+}

package/src/index.tsx

@@ -0,0 +1,41 @@
+// Generated by uniffi-bindgen-react-native
+import installer from './NativeNobodywho';
+
+// Register the rust crate with Hermes
+// - the boolean flag ensures this loads exactly once, even if the JS
+//   code is reloaded (e.g. during development with metro).
+let rustInstalled = false;
+if (!rustInstalled) {
+  installer.installRustCrate();
+  rustInstalled = true;
+}
+
+// Export the generated bindings to the app.
+export * from './../generated/ts/nobodywho';
+
+// Now import the bindings so we can:
+// - intialize them
+// - export them as namespaced objects as the default export.
+import * as nobodywho from './../generated/ts/nobodywho';
+
+// Initialize the generated bindings: mostly checksums, but also callbacks.
+// - the boolean flag ensures this loads exactly once, even if the JS code
+//   is reloaded (e.g. during development with metro).
+let initialized = false;
+if (!initialized) {
+  nobodywho.default.initialize();
+  initialized = true;
+}
+
+// This provides parity with the index.web.ts version of this file.
+// The web version relies on an asynchronous fetch, which this doesn't
+// need, so we just no-op.
+export async function uniffiInitAsync() {
+  // NOOP.
+}
+
+// Export the crates as individually namespaced objects.
+export default {
+  nobodywho,
+};
+

package/src/prompt.ts

@@ -0,0 +1,72 @@
+import { PromptPart } from "../generated/ts/nobodywho";
+
+/** A text part of a multimodal prompt. */
+class TextPart {
+  /** @internal */
+  readonly _inner: PromptPart;
+
+  constructor(content: string) {
+    this._inner = new PromptPart.Text({ content });
+  }
+}
+
+/** An image part of a multimodal prompt. */
+class ImagePart {
+  /** @internal */
+  readonly _inner: PromptPart;
+
+  constructor(path: string) {
+    this._inner = new PromptPart.Image({ path });
+  }
+}
+
+/** An audio part of a multimodal prompt. */
+class AudioPart {
+  /** @internal */
+  readonly _inner: PromptPart;
+
+  constructor(path: string) {
+    this._inner = new PromptPart.Audio({ path });
+  }
+}
+
+type Part = TextPart | ImagePart | AudioPart;
+
+/**
+ * A multimodal prompt composed of text, image, and audio parts.
+ *
+ * @example
+ * ```typescript
+ * const prompt = new Prompt([
+ *   Prompt.Text("Tell me what you see in the first image."),
+ *   Prompt.Image("./dog.png"),
+ *   Prompt.Text("Also tell me what you see in the second image."),
+ *   Prompt.Image("./penguin.png"),
+ * ]);
+ *
+ * const stream = chat.ask(prompt);
+ * ```
+ */
+export class Prompt {
+  /** @internal */
+  readonly _parts: PromptPart[];
+
+  constructor(parts: Part[]) {
+    this._parts = parts.map((p) => p._inner);
+  }
+
+  /** Create a text part. */
+  static Text(content: string): TextPart {
+    return new TextPart(content);
+  }
+
+  /** Create an image part from a file path. */
+  static Image(path: string): ImagePart {
+    return new ImagePart(path);
+  }
+
+  /** Create an audio part from a file path. */
+  static Audio(path: string): AudioPart {
+    return new AudioPart(path);
+  }
+}

package/src/sampler_presets.ts

@@ -0,0 +1,64 @@
+import type { SamplerConfigInterface } from "../generated/ts/nobodywho";
+import {
+  samplerPresetDefault,
+  samplerPresetDry,
+  samplerPresetGrammar,
+  samplerPresetGreedy,
+  samplerPresetJson,
+  samplerPresetTemperature,
+  samplerPresetTopK,
+  samplerPresetTopP,
+} from "../generated/ts/nobodywho";
+
+/**
+ * Static factory methods for common sampler configurations.
+ *
+ * @example
+ * ```typescript
+ * const sampler = SamplerPresets.temperature(0.7);
+ * const chat = new Chat(model, undefined, 4096, undefined, undefined, sampler);
+ * ```
+ */
+export class SamplerPresets {
+  private constructor() {}
+
+  /** Get the default sampler configuration. */
+  static default(): SamplerConfigInterface {
+    return samplerPresetDefault();
+  }
+
+  /** Create a sampler with top-k filtering only. */
+  static topK(topK: number): SamplerConfigInterface {
+    return samplerPresetTopK(topK);
+  }
+
+  /** Create a sampler with nucleus (top-p) sampling. */
+  static topP(topP: number): SamplerConfigInterface {
+    return samplerPresetTopP(topP);
+  }
+
+  /** Create a greedy sampler (always picks most probable token). */
+  static greedy(): SamplerConfigInterface {
+    return samplerPresetGreedy();
+  }
+
+  /** Create a sampler with temperature scaling. */
+  static temperature(temperature: number): SamplerConfigInterface {
+    return samplerPresetTemperature(temperature);
+  }
+
+  /** Create a DRY sampler preset to reduce repetition. */
+  static dry(): SamplerConfigInterface {
+    return samplerPresetDry();
+  }
+
+  /** Create a sampler configured for JSON output generation. */
+  static json(): SamplerConfigInterface {
+    return samplerPresetJson();
+  }
+
+  /** Create a sampler with a custom grammar constraint. */
+  static grammar(grammar: string): SamplerConfigInterface {
+    return samplerPresetGrammar(grammar);
+  }
+}

package/src/streaming.ts

@@ -0,0 +1,46 @@
+import type { RustTokenStreamInterface } from "../generated/ts/nobodywho";
+
+/**
+ * A stream of response tokens from the model.
+ *
+ * Wraps the internal RustTokenStream and provides an async iterable interface
+ * so it can be used with `for await`.
+ *
+ * @example
+ * ```typescript
+ * const stream = chat.ask("Hello!");
+ * for await (const token of stream) {
+ *   process.stdout.write(token);
+ * }
+ * // Or get the complete response:
+ * const stream = chat.ask("Hello!");
+ * const fullResponse = await stream.completed();
+ * ```
+ */
+export class TokenStream implements AsyncIterable<string> {
+  /** @internal */
+  readonly _inner: RustTokenStreamInterface;
+
+  /** @internal */
+  constructor(inner: RustTokenStreamInterface) {
+    this._inner = inner;
+  }
+
+  /** Get the next token. Returns undefined when generation is complete. */
+  async nextToken(): Promise<string | undefined> {
+    return this._inner.nextToken();
+  }
+
+  /** Wait for the full response to complete and return it. */
+  async completed(): Promise<string> {
+    return this._inner.completed();
+  }
+
+  /** Async iterator support for `for await (const token of stream)`. */
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<string> {
+    let token: string | undefined;
+    while ((token = await this._inner.nextToken()) !== undefined) {
+      yield token;
+    }
+  }
+}

package/src/tool.ts

@@ -0,0 +1,80 @@
+import {
+  RustTool,
+  type RustToolCallback,
+  type ToolParameter,
+} from "../generated/ts/nobodywho";
+
+/**
+ * Convert a value from JSON based on the JSON Schema type.
+ */
+function convertValue(
+  value: unknown,
+  schema: Record<string, unknown>,
+): unknown {
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return Number(value);
+    case "boolean":
+      return typeof value === "string" ? value === "true" : Boolean(value);
+    case "string":
+      return String(value);
+    default:
+      return value;
+  }
+}
+
+/**
+ * A tool that the model can call during inference.
+ *
+ * Wraps the internal RustTool with an ergonomic API that handles
+ * JSON parsing and typed argument dispatch.
+ *
+ * @example
+ * ```typescript
+ * const weatherTool = new Tool({
+ *   name: "get_weather",
+ *   description: "Get the current weather for a city",
+ *   parameters: {
+ *     city: { type: "string" },
+ *     unit: { type: "string", enum: ["celsius", "fahrenheit"] },
+ *   },
+ *   call: ({ city, unit }) => JSON.stringify({ temp: 22, unit }),
+ * });
+ * ```
+ */
+export class Tool {
+  /** @internal */
+  readonly _inner: RustTool;
+
+  constructor(opts: {
+    name: string;
+    description: string;
+    parameters: Record<string, Record<string, unknown>>;
+    call: (args: Record<string, unknown>) => string;
+  }) {
+    const paramEntries = Object.entries(opts.parameters);
+
+    const callback: RustToolCallback = {
+      call(argumentsJson: string): string {
+        const parsed = JSON.parse(argumentsJson);
+        const args: Record<string, unknown> = {};
+        for (const [paramName, schema] of paramEntries) {
+          args[paramName] = convertValue(parsed[paramName], schema);
+        }
+        return opts.call(args);
+      },
+    };
+
+    const toolParams: ToolParameter[] = paramEntries.map(
+      ([name, schema]) => ({ name, schema: JSON.stringify(schema) }),
+    );
+
+    this._inner = new RustTool(opts.name, opts.description, toolParams, callback);
+  }
+
+  /** Get the JSON schema for this tool's parameters. */
+  getSchemaJson(): string {
+    return this._inner.getSchemaJson();
+  }
+}

package/ubrn.config.yaml

@@ -0,0 +1,12 @@
+---
+rust:
+  directory: ..
+  manifestPath: uniffi/Cargo.toml
+
+bindings:
+  cpp: generated/cpp
+  ts: generated/ts
+
+turboModule:
+  cpp: cpp
+  ts: src