bleam 0.0.10 → 0.0.12

package/templates/native/modules/bleam-runtime/ios/GenerationContracts.swift

@@ -3,12 +3,15 @@ import Foundation
 @objc protocol GenerationServiceProtocol {
   func startGeneration(requestData: Data, reply: @escaping (Bool) -> Void)
   func cancelGeneration(reply: @escaping (Bool) -> Void)
+  func startTextGeneration(requestData: Data, reply: @escaping (Bool) -> Void)
+  func cancelTextGeneration(id: String, reply: @escaping (Bool) -> Void)
   func memoryTelemetry(reply: @escaping (Data?) -> Void)
   func shutdown(reply: @escaping (Bool) -> Void)
 }
 
 @objc protocol GenerationServiceClientProtocol {
   func generationWorkerDidEmit(eventData: Data)
+  func textGenerationWorkerDidEmit(eventData: Data)
 }
 
 struct GenerationWorkerRequest: Codable, Sendable {
@@ -133,3 +136,47 @@ struct GenerationWorkerLoRA: Codable, Sendable {
   let path: String
   let scale: Double
 }
+
+struct BonsaiTextGenerationRequest: Codable, Sendable {
+  let id: String
+  let model: String
+  let modelPath: String
+  let inputIDs: [Int]
+  let endTokenIDs: [Int]
+  let maximumNewTokens: Int?
+  let temperature: Double?
+  let topP: Double?
+  let topK: Int?
+  let repetitionPenalty: Double?
+  let repetitionContextSize: Int?
+  let seed: Int?
+}
+
+struct BonsaiTextGenerationEvent: Codable, Sendable {
+  enum EventType: String, Codable, Sendable {
+    case update
+    case completed
+    case canceled
+    case failed
+  }
+
+  let type: EventType
+  let id: String
+  let tokenIDs: [Int]
+  let finishReason: String?
+  let message: String?
+
+  init(
+    type: EventType,
+    id: String,
+    tokenIDs: [Int] = [],
+    finishReason: String? = nil,
+    message: String? = nil
+  ) {
+    self.type = type
+    self.id = id
+    self.tokenIDs = tokenIDs
+    self.finishReason = finishReason
+    self.message = message
+  }
+}

package/templates/native/modules/bleam-runtime/ios/PlatformModule.swift

@@ -6,70 +6,10 @@ import ExpoModulesCore
 import Foundation
 import Photos
 
-@objc private protocol PlatformHelperProtocol {
-  func health(reply: @escaping (Data?) -> Void)
-  func downloadPlatformUpdate(requestData: Data, reply: @escaping (Data?) -> Void)
-  func applyPlatformUpdate(requestData: Data, reply: @escaping (Bool) -> Void)
-}
-
 public final class PlatformModule: Module {
   public func definition() -> ModuleDefinition {
     Name("Platform")
 
-    AsyncFunction("helperStatus") { (promise: Promise) in
-      guard Self.isSupportedInstallLocation else {
-        UserDefaults.standard.set(false, forKey: "BleamPlatformUpdatesSupported")
-        promise.resolve([
-          "healthy": false,
-          "protocolVersion": 1,
-          "helperVersion": "unavailable",
-          "platformVersion": "unavailable",
-          "capabilities": [],
-          "updatesSupported": false,
-          "installPath": Bundle.main.bundleURL.path,
-          "reason": "reinstall_required",
-        ])
-        return
-      }
-      let serviceName = "\(Bundle.main.bundleIdentifier ?? "dev.bleam.app").PlatformHelper"
-      guard let connection = Self.makeConnection(serviceName: serviceName) else {
-        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
-        return
-      }
-      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
-      connection.resume()
-
-      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
-        connection.invalidate()
-        promise.reject("HELPER_UNAVAILABLE", error.localizedDescription)
-      }) as? PlatformHelperProtocol else {
-        connection.invalidate()
-        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
-        return
-      }
-
-      service.health { data in
-        defer { connection.invalidate() }
-        guard
-          let data,
-          var status = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
-        else {
-          promise.reject("HELPER_INVALID_RESPONSE", "The app helper returned an invalid response")
-          return
-        }
-        let supported = Self.isSupportedInstallLocation
-        status["updatesSupported"] = supported
-        status["installPath"] = Bundle.main.bundleURL.path
-        if !supported {
-          status["reason"] = "reinstall_required"
-        }
-        UserDefaults.standard.set(status["healthy"], forKey: "BleamHelperHealthy")
-        UserDefaults.standard.set(status["platformVersion"], forKey: "BleamHelperPlatformVersion")
-        UserDefaults.standard.set(supported, forKey: "BleamPlatformUpdatesSupported")
-        promise.resolve(status)
-      }
-    }
-
     AsyncFunction("permissionState") { (capability: String, promise: Promise) in
       guard let state = Self.permissionState(capability) else {
         promise.reject("INVALID_CAPABILITY", "Unknown permission capability: \(capability)")
@@ -85,132 +25,6 @@ public final class PlatformModule: Module {
       }
       promise.resolve(states)
     }
-
-    AsyncFunction("downloadPlatformUpdate") { (promise: Promise) in
-      guard Self.isSupportedInstallLocation else {
-        promise.reject("REINSTALL_REQUIRED", "Platform updates require the app to be installed directly in ~/Applications")
-        return
-      }
-      guard
-        let serviceURL = Bundle.main.object(forInfoDictionaryKey: "BleamUpdateServiceURL") as? String,
-        let bundleIdentifier = Bundle.main.bundleIdentifier,
-        let teamIdentifier = Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
-        let platformVersion = Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String,
-        let platformFingerprint = Bundle.main.object(forInfoDictionaryKey: "BleamPlatformFingerprint") as? String,
-        let requestData = try? JSONSerialization.data(withJSONObject: [
-          "serviceURL": serviceURL,
-          "bundleIdentifier": bundleIdentifier,
-          "teamIdentifier": teamIdentifier,
-          "platformVersion": platformVersion,
-          "platformFingerprint": platformFingerprint,
-        ])
-      else {
-        promise.reject("UPDATES_UNAVAILABLE", "Platform updates are not configured")
-        return
-      }
-
-      guard let connection = Self.makeConnection(serviceName: "\(bundleIdentifier).PlatformHelper") else {
-        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
-        return
-      }
-      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
-      connection.resume()
-      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
-        connection.invalidate()
-        promise.reject("PLATFORM_DOWNLOAD_FAILED", error.localizedDescription)
-      }) as? PlatformHelperProtocol else {
-        connection.invalidate()
-        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
-        return
-      }
-
-      service.downloadPlatformUpdate(requestData: requestData) { data in
-        defer { connection.invalidate() }
-        guard
-          let data,
-          let result = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
-        else {
-          promise.reject("PLATFORM_DOWNLOAD_FAILED", "The platform update could not be downloaded")
-          return
-        }
-        if let error = result["error"] as? String {
-          UserDefaults.standard.set(error, forKey: "BleamPlatformDownloadError")
-          promise.reject("PLATFORM_VERIFICATION_FAILED", error)
-          return
-        }
-        UserDefaults.standard.set(result["releaseId"], forKey: "BleamPlatformDownloadRelease")
-        promise.resolve(result)
-      }
-    }
-
-    AsyncFunction("updateAndRelaunch") { (releaseId: String, promise: Promise) in
-      guard Self.isSupportedInstallLocation else {
-        promise.reject("REINSTALL_REQUIRED", "Platform updates require the app to be installed directly in ~/Applications")
-        return
-      }
-      guard
-        let bundleIdentifier = Bundle.main.bundleIdentifier,
-        let teamIdentifier = Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
-        let requestData = try? JSONSerialization.data(withJSONObject: [
-          "releaseId": releaseId,
-          "bundleIdentifier": bundleIdentifier,
-          "teamIdentifier": teamIdentifier,
-          "installedAppPath": Bundle.main.bundleURL.path,
-          "appPID": ProcessInfo.processInfo.processIdentifier,
-        ]),
-        let connection = Self.makeConnection(serviceName: "\(bundleIdentifier).PlatformHelper")
-      else {
-        promise.reject("PLATFORM_UPDATE_UNAVAILABLE", "The platform update cannot be applied")
-        return
-      }
-      connection.remoteObjectInterface = NSXPCInterface(with: PlatformHelperProtocol.self)
-      connection.resume()
-      guard let service = connection.remoteObjectProxyWithErrorHandler({ error in
-        connection.invalidate()
-        promise.reject("PLATFORM_UPDATE_FAILED", error.localizedDescription)
-      }) as? PlatformHelperProtocol else {
-        connection.invalidate()
-        promise.reject("HELPER_UNAVAILABLE", "The app helper is unavailable")
-        return
-      }
-      service.applyPlatformUpdate(requestData: requestData) { accepted in
-        connection.invalidate()
-        UserDefaults.standard.set(accepted, forKey: "BleamPlatformApplyAccepted")
-        guard accepted else {
-          promise.reject("PLATFORM_UPDATE_REJECTED", "The platform update is not verified or the app is not installed in ~/Applications")
-          return
-        }
-        promise.resolve(nil)
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-          exit(0)
-        }
-      }
-    }
-  }
-
-  private static func makeConnection(serviceName: String) -> NSXPCConnection? {
-#if targetEnvironment(macCatalyst)
-    let connectionClass: AnyObject = NSXPCConnection.self as AnyObject
-    let allocated = connectionClass.perform(NSSelectorFromString("alloc"))?.takeUnretainedValue() as AnyObject?
-    let selector = NSSelectorFromString("initWithMachServiceName:options:")
-    guard let allocated, allocated.responds(to: selector) else { return nil }
-
-    typealias Initializer = @convention(c) (
-      AnyObject,
-      Selector,
-      NSString,
-      UInt
-    ) -> Unmanaged<AnyObject>
-    let initialize = unsafeBitCast(allocated.method(for: selector), to: Initializer.self)
-    return initialize(
-      allocated,
-      selector,
-      serviceName as NSString,
-      0
-    ).takeRetainedValue() as? NSXPCConnection
-#else
-    return NSXPCConnection(machServiceName: serviceName)
-#endif
   }
 
   private static let permissionCapabilities = [
@@ -321,9 +135,4 @@ public final class PlatformModule: Module {
     }
   }
 
-  private static var isSupportedInstallLocation: Bool {
-    let applications = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
-      .appendingPathComponent("Applications", isDirectory: true).standardizedFileURL
-    return Bundle.main.bundleURL.standardizedFileURL.deletingLastPathComponent() == applications
-  }
 }

package/templates/text-generation/app/index.tsx

@@ -0,0 +1,124 @@
+import { bonsai, chat, prepareTextModel, useChat, useChatList } from 'bleam/ai'
+import { sx } from 'bleam/styles'
+import { Button } from 'bleam/ui'
+import { Window } from 'bleam/window'
+import { useEffect, useRef, useState } from 'react'
+import { Text, TextInput, View } from 'react-native'
+
+const appName = 'Bleam Basic'
+const model = bonsai('ternary-bonsai-4b')
+
+export default function App() {
+  const chats = useChatList()
+  const creating = useRef(false)
+  const [path, setPath] = useState<string | null>(null)
+  const [status, setStatus] = useState('Preparing local model...')
+
+  useEffect(() => {
+    if (chats.length > 0 || creating.current) return
+    creating.current = true
+    void chat.create({ title: 'Private writing' }).catch((error) => {
+      setStatus(error instanceof Error ? error.message : String(error))
+    })
+  }, [chats.length])
+
+  useEffect(() => {
+    const controller = new AbortController()
+    void prepareTextModel(model, {
+      signal: controller.signal,
+      onProgress(progress) {
+        setStatus(
+          `Preparing model ${Math.round(progress.modelFraction * 100)}%`,
+        )
+      },
+    })
+      .then((prepared) => {
+        setPath(prepared.path)
+        setStatus('Ready')
+      })
+      .catch((error) => {
+        if (!controller.signal.aborted) {
+          setStatus(error instanceof Error ? error.message : String(error))
+        }
+      })
+    return () => controller.abort()
+  }, [])
+
+  return (
+    <View style={sx('flex-1', 'p-8', 'gap-6')}>
+      <Window title={appName} />
+      <Text style={sx('text-3xl', 'font-semibold')}>
+        Private Writing Assistant
+      </Text>
+      <Text style={sx('text-secondary-label')}>
+        Ternary Bonsai runs locally after its first model download. Chats return
+        after relaunch.
+      </Text>
+      <Text style={sx('text-secondary-label')}>{status}</Text>
+      {path && chats[0] ? <Conversation id={chats[0].id} path={path} /> : null}
+    </View>
+  )
+}
+
+function Conversation({ id, path }: { id: string; path: string }) {
+  const conversation = useChat(id, {
+    model,
+    path,
+    system: 'You are a concise private writing assistant.',
+  })
+  const [prompt, setPrompt] = useState(
+    'Rewrite this note so it is clear and concise: We should probably meet sometime next week to discuss the launch.',
+  )
+  const latestAssistant = conversation.messages.findLast(
+    (message) => message.role === 'assistant',
+  )
+  const retryable =
+    latestAssistant?.status === 'failed' ||
+    latestAssistant?.status === 'canceled'
+      ? latestAssistant
+      : null
+
+  return (
+    <View style={sx('gap-6')}>
+      <TextInput
+        multiline
+        value={prompt}
+        onChangeText={setPrompt}
+        style={sx(
+          { minHeight: 128 },
+          'rounded-xl',
+          'border',
+          'border-separator',
+          'p-4',
+        )}
+      />
+      <View style={sx('flex-row', 'gap-3')}>
+        <Button
+          title="Send"
+          loading={conversation.isGenerating}
+          disabled={!conversation.canSend}
+          onPress={() => void conversation.send(prompt)}
+        />
+        <Button
+          title="Cancel"
+          variant="secondary"
+          disabled={!conversation.canCancel}
+          onPress={() => void conversation.cancel()}
+        />
+        {retryable ? (
+          <Button
+            title="Retry"
+            variant="secondary"
+            onPress={() => void conversation.retry(retryable.id)}
+          />
+        ) : null}
+      </View>
+      {conversation.messages.map((message) => (
+        <Text key={message.id} style={sx('text-lg', 'text-label')}>
+          {message.role === 'user' ? 'You: ' : 'Assistant: '}
+          {message.content || message.status}
+        </Text>
+      ))}
+    </View>
+  )
+}

package/templates/text-generation/app.config.ts

@@ -0,0 +1,5 @@
+import { appConfig } from 'bleam'
+
+export default appConfig({
+  name: 'Bleam Basic',
+})