bleam 0.0.11 → 0.0.13

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

@@ -9,96 +9,10 @@ import FoundationModels
 
 public final class AIModule: Module {
   @MainActor private let textGeneration = TextGenerationCoordinator()
-  private static var appGroupIdentifier: String {
-    Bundle.main.object(forInfoDictionaryKey: "AppGroupIdentifier") as? String ?? "group.dev.bleam.app"
-  }
 
   public func definition() -> ModuleDefinition {
     Name("AI")
-    Events("imagegenProgress", "textGenerationUpdate", "localTextGenerationUpdate", "toolCall")
-
-    Function("isAvailable") { () -> Bool in
-#if canImport(FoundationModels)
-      if #available(iOS 26, *) {
-        return SystemLanguageModel.default.availability == .available
-      }
-#endif
-      return false
-    }
-
-    Function("availability") { () -> [String: Any] in
-#if canImport(FoundationModels)
-      if #available(iOS 26, *) {
-        switch SystemLanguageModel.default.availability {
-        case .available:
-          return ["available": true]
-        case .unavailable(.deviceNotEligible):
-          return ["available": false, "reason": "device_not_eligible"]
-        case .unavailable(.appleIntelligenceNotEnabled):
-          return ["available": false, "reason": "apple_intelligence_not_enabled"]
-        case .unavailable(.modelNotReady):
-          return ["available": false, "reason": "model_not_ready"]
-        case .unavailable:
-          return ["available": false, "reason": "unknown"]
-        }
-      }
-#endif
-      return ["available": false, "reason": "unknown"]
-    }
-
-    AsyncFunction("generate") { [weak self] (request: TextGenerationRequest, promise: Promise) in
-#if canImport(FoundationModels)
-      if #available(iOS 26, *) {
-        guard SystemLanguageModel.default.availability == .available else {
-          promise.reject("MODEL_UNAVAILABLE", "Apple Intelligence model is not available")
-          return
-        }
-
-        guard !request.prompt.isEmpty else {
-          promise.reject("INVALID_MESSAGE", "Expected prompt")
-          return
-        }
-
-        let generationID = request.id ?? UUID().uuidString
-        let task = Task { @MainActor [weak self] in
-          guard let self else { return }
-          do {
-            let tools = try Self.tools(
-              from: request.tools,
-              generationID: generationID,
-              coordinator: self.textGeneration,
-              emit: { [weak self] event in self?.sendEvent("toolCall", event) }
-            )
-            let session = Self.session(system: request.system, tools: tools)
-            let options = try Self.generationOptions(from: request)
-
-            if let schema = request.outputSchema {
-              let generationSchema = try Self.generationSchema(from: schema)
-              let response = try await session.respond(
-                to: request.prompt,
-                schema: generationSchema,
-                includeSchemaInPrompt: true,
-                options: options
-              )
-              promise.resolve(try Self.value(from: response.content, schema: schema))
-              return
-            }
-
-            let response = try await session.respond(to: request.prompt, options: options)
-            promise.resolve(response.content)
-          } catch {
-            Self.reject(error, promise: promise)
-          }
-          self.textGeneration.finish(generationID)
-        }
-        Task { @MainActor [weak self] in self?.textGeneration.start(generationID, task: task) }
-      } else {
-        promise.reject("UNSUPPORTED_OS", "Apple Foundation Models require iOS 26 or newer")
-      }
-#else
-      promise.reject("UNSUPPORTED_OS", "Apple Foundation Models are unavailable in this build")
-#endif
-    }
+    Events("imagegenProgress", "textGenerationUpdate", "localTextGenerationUpdate")
 
     AsyncFunction("streamGenerate") { [weak self] (request: TextGenerationRequest, promise: Promise) in
 #if canImport(FoundationModels)
@@ -116,13 +30,7 @@ public final class AIModule: Module {
         let task = Task { @MainActor [weak self] in
           guard let self else { return }
           do {
-            let tools = try Self.tools(
-              from: request.tools,
-              generationID: generationID,
-              coordinator: self.textGeneration,
-              emit: { [weak self] event in self?.sendEvent("toolCall", event) }
-            )
-            let session = Self.session(system: request.system, tools: tools)
+            let session = try Self.session(system: request.system, messages: request.messages)
             let options = try Self.generationOptions(from: request)
             let stream = session.streamResponse(to: request.prompt, options: options)
             var content = ""
@@ -152,23 +60,6 @@ public final class AIModule: Module {
       return foundationCanceled || localCanceled
     }
 
-    AsyncFunction("resolveToolCall") { [weak self] (request: ToolResultRequest) -> Bool in
-      await self?.textGeneration.resolve(request) ?? false
-    }
-
-    AsyncFunction("generateLocalText") { (request: LocalTextGenerationRequest, promise: Promise) in
-      Task { @MainActor in
-        do {
-          let event = try await ImageGenerationServiceClient.shared.runText(
-            request: Self.bonsaiTextRequest(from: request)
-          )
-          promise.resolve(event.tokenIDs)
-        } catch {
-          Self.rejectLocalTextGeneration(error, promise: promise)
-        }
-      }
-    }
-
     AsyncFunction("streamLocalText") { [weak self] (request: LocalTextGenerationRequest, promise: Promise) in
       Task { @MainActor in
         do {
@@ -488,13 +379,15 @@ public final class AIModule: Module {
 
   private static func workerRequest(from request: FluxImageRequest) throws -> GenerationWorkerRequest {
     let jobID = UUID()
-    guard let appGroupContainer = FileManager.default.containerURL(
-      forSecurityApplicationGroupIdentifier: appGroupIdentifier
-    ) else {
-      throw ModuleError.imageGeneration("Shared generation container is unavailable")
+    guard let cacheDirectory = FileManager.default.urls(
+      for: .cachesDirectory,
+      in: .userDomainMask
+    ).first else {
+      throw ModuleError.imageGeneration("Generation cache is unavailable")
     }
 
-    let stagingDirectory = appGroupContainer
+    let stagingDirectory = cacheDirectory
+      .appendingPathComponent("Bleam", isDirectory: true)
       .appendingPathComponent("GenerationRuns", isDirectory: true)
       .appendingPathComponent("bleam-generation-jobs", isDirectory: true)
       .appendingPathComponent(jobID.uuidString, isDirectory: true)
@@ -627,31 +520,35 @@ public final class AIModule: Module {
 
 #if canImport(FoundationModels)
   @available(iOS 26, *)
-  private static func session(system: String?, tools: [any Tool]) -> LanguageModelSession {
-    if let system, !system.isEmpty {
-      return LanguageModelSession(tools: tools, instructions: system)
+  private static func session(
+    system: String?,
+    messages: [TextMessageRequest]
+  ) throws -> LanguageModelSession {
+    if !messages.isEmpty {
+      var entries: [Transcript.Entry] = []
+      if system?.isEmpty == false {
+        entries.append(.instructions(Transcript.Instructions(
+          segments: system.map { [.text(Transcript.TextSegment(content: $0))] } ?? [],
+          toolDefinitions: []
+        )))
+      }
+      for message in messages {
+        let segments: [Transcript.Segment] = [.text(Transcript.TextSegment(content: message.content))]
+        switch message.role {
+        case "user":
+          entries.append(.prompt(Transcript.Prompt(segments: segments)))
+        case "assistant":
+          entries.append(.response(Transcript.Response(assetIDs: [], segments: segments)))
+        default:
+          throw ModuleError.invalidMessage("Unsupported transcript role: \(message.role)")
+        }
+      }
+      return LanguageModelSession(transcript: Transcript(entries: entries))
     }
-    return LanguageModelSession(tools: tools)
-  }
-
-  @available(iOS 26, *)
-  private static func tools(
-    from definitions: [ToolDefinitionRequest],
-    generationID: String,
-    coordinator: TextGenerationCoordinator,
-    emit: @escaping @MainActor @Sendable ([String: Any]) -> Void
-  ) throws -> [any Tool] {
-    try definitions.map { definition in
-      let parameters = try generationSchema(from: definition.inputSchema)
-      return DynamicTool(
-        name: definition.name,
-        description: definition.description,
-        parameters: parameters,
-        generationID: generationID,
-        coordinator: coordinator,
-        emit: emit
-      )
+    if let system, !system.isEmpty {
+      return LanguageModelSession(instructions: system)
     }
+    return LanguageModelSession()
   }
 
   @available(iOS 26, *)
@@ -663,131 +560,6 @@ public final class AIModule: Module {
     )
   }
 
-  @available(iOS 26, *)
-  private static func generationSchema(from schema: [String: Any]) throws -> GenerationSchema {
-    do {
-      return try GenerationSchema(root: dynamicSchema(from: schema), dependencies: [])
-    } catch {
-      throw ModuleError.invalidSchema(error.localizedDescription)
-    }
-  }
-
-  @available(iOS 26, *)
-  private static func dynamicSchema(from schema: [String: Any]) throws -> DynamicGenerationSchema {
-    guard let type = schema["type"] as? String else {
-      throw ModuleError.invalidSchema("Missing schema type")
-    }
-
-    switch type {
-    case "object":
-      return try objectSchema(from: schema)
-    case "array":
-      guard let itemSchema = schema["items"] as? [String: Any] else {
-        throw ModuleError.invalidSchema("Array schema must include items")
-      }
-      return try DynamicGenerationSchema(arrayOf: dynamicSchema(from: itemSchema))
-    case "string":
-      return DynamicGenerationSchema(type: String.self)
-    case "number":
-      return DynamicGenerationSchema(type: Double.self)
-    case "boolean":
-      return DynamicGenerationSchema(type: Bool.self)
-    default:
-      throw ModuleError.invalidSchema("Unsupported schema type: \(type)")
-    }
-  }
-
-  @available(iOS 26, *)
-  private static func objectSchema(from schema: [String: Any]) throws -> DynamicGenerationSchema {
-    let propertiesDictionary = schema["properties"] as? [String: Any] ?? [:]
-    let required = Set(schema["required"] as? [String] ?? [])
-    var properties: [DynamicGenerationSchema.Property] = []
-
-    for key in propertiesDictionary.keys.sorted() {
-      guard let propertySchema = propertiesDictionary[key] as? [String: Any] else {
-        throw ModuleError.invalidSchema("Property \(key) schema must be an object")
-      }
-
-      properties.append(
-        DynamicGenerationSchema.Property(
-          name: key,
-          description: nil,
-          schema: try dynamicSchema(from: propertySchema),
-          isOptional: !required.contains(key)
-        )
-      )
-    }
-
-    return DynamicGenerationSchema(name: schema["title"] as? String ?? "Output", properties: properties)
-  }
-
-  @available(iOS 26, *)
-  private static func value(from content: GeneratedContent, schema: [String: Any]) throws -> Any {
-    guard let type = schema["type"] as? String else {
-      throw ModuleError.invalidSchema("Missing schema type")
-    }
-
-    switch type {
-    case "object":
-      let propertiesDictionary = schema["properties"] as? [String: Any] ?? [:]
-      let output = NSMutableDictionary()
-
-      for key in propertiesDictionary.keys.sorted() {
-        guard let propertySchema = propertiesDictionary[key] as? [String: Any] else {
-          throw ModuleError.invalidSchema("Property \(key) schema must be an object")
-        }
-        output[key] = try propertyValue(from: content, property: key, schema: propertySchema)
-      }
-
-      return output
-    default:
-      throw ModuleError.invalidSchema("Root schema must be an object")
-    }
-  }
-
-  @available(iOS 26, *)
-  private static func propertyValue(
-    from content: GeneratedContent,
-    property: String,
-    schema: [String: Any]
-  ) throws -> Any {
-    guard let type = schema["type"] as? String else {
-      throw ModuleError.invalidSchema("Missing schema type")
-    }
-
-    switch type {
-    case "string":
-      return try content.value(String.self, forProperty: property)
-    case "number":
-      return try content.value(Double.self, forProperty: property)
-    case "boolean":
-      return try content.value(Bool.self, forProperty: property)
-    case "object":
-      let nestedContent = try content.value(GeneratedContent.self, forProperty: property)
-      return try value(from: nestedContent, schema: schema)
-    case "array":
-      guard let itemSchema = schema["items"] as? [String: Any], let itemType = itemSchema["type"] as? String else {
-        throw ModuleError.invalidSchema("Array schema must include items")
-      }
-
-      switch itemType {
-      case "string":
-        return try content.value([String].self, forProperty: property)
-      case "number":
-        return try content.value([Double].self, forProperty: property)
-      case "boolean":
-        return try content.value([Bool].self, forProperty: property)
-      case "object":
-        let values = try content.value([GeneratedContent].self, forProperty: property)
-        return try values.map { try value(from: $0, schema: itemSchema) }
-      default:
-        throw ModuleError.invalidSchema("Unsupported array item type: \(itemType)")
-      }
-    default:
-      throw ModuleError.invalidSchema("Unsupported schema type: \(type)")
-    }
-  }
-
   @available(iOS 26, *)
   private static func reject(_ error: Error, promise: Promise) {
     if error is CancellationError {
@@ -811,55 +583,14 @@ public final class AIModule: Module {
       }
       return
     }
-    if let toolError = error as? LanguageModelSession.ToolCallError {
-      promise.reject("TOOL_ERROR", toolError.localizedDescription)
-      return
-    }
-
     promise.reject(error)
   }
 #endif
 }
 
-#if canImport(FoundationModels)
-@available(iOS 26, *)
-private struct DynamicTool: Tool {
-  typealias Arguments = GeneratedContent
-
-  let name: String
-  let description: String
-  let parameters: GenerationSchema
-  let generationID: String
-  let coordinator: TextGenerationCoordinator
-  let emit: @MainActor @Sendable ([String: Any]) -> Void
-
-  func call(arguments: GeneratedContent) async throws -> String {
-    let data = Data(arguments.jsonString.utf8)
-    let value = try JSONSerialization.jsonObject(with: data)
-    return try await coordinator.call(
-      generationID: generationID,
-      name: name,
-      arguments: value,
-      emit: emit
-    )
-  }
-}
-#endif
-
-private struct ToolExecutionError: LocalizedError {
-  let message: String
-  var errorDescription: String? { message }
-}
-
 @MainActor
 private final class TextGenerationCoordinator {
-  private struct PendingToolCall {
-    let generationID: String
-    let continuation: CheckedContinuation<String, Error>
-  }
-
   private var tasks: [String: Task<Void, Never>] = [:]
-  private var toolCalls: [String: PendingToolCall] = [:]
 
   func start(_ id: String, task: Task<Void, Never>) {
     tasks[id]?.cancel()
@@ -868,67 +599,22 @@ private final class TextGenerationCoordinator {
 
   func finish(_ id: String) {
     tasks[id] = nil
-    failToolCalls(for: id, error: CancellationError())
   }
 
   func cancel(_ id: String) -> Bool {
     guard let task = tasks.removeValue(forKey: id) else { return false }
     task.cancel()
-    failToolCalls(for: id, error: CancellationError())
     return true
   }
-
-  func call(
-    generationID: String,
-    name: String,
-    arguments: Any,
-    emit: @escaping @MainActor @Sendable ([String: Any]) -> Void
-  ) async throws -> String {
-    try Task.checkCancellation()
-    let callID = UUID().uuidString
-    return try await withCheckedThrowingContinuation { continuation in
-      toolCalls[callID] = PendingToolCall(generationID: generationID, continuation: continuation)
-      emit([
-        "generationId": generationID,
-        "callId": callID,
-        "name": name,
-        "arguments": arguments,
-      ])
-    }
-  }
-
-  func resolve(_ request: ToolResultRequest) -> Bool {
-    guard let pending = toolCalls.removeValue(forKey: request.callId),
-      pending.generationID == request.generationId
-    else { return false }
-
-    if let error = request.error {
-      pending.continuation.resume(throwing: ToolExecutionError(message: error))
-    } else {
-      pending.continuation.resume(returning: request.output ?? "")
-    }
-    return true
-  }
-
-  private func failToolCalls(for generationID: String, error: Error) {
-    let matches = toolCalls.filter { $0.value.generationID == generationID }
-    for (id, pending) in matches {
-      toolCalls[id] = nil
-      pending.continuation.resume(throwing: error)
-    }
-  }
 }
 
 private enum ModuleError: Error, LocalizedError {
-  case invalidSchema(String)
   case invalidMessage(String)
   case invalidModel(String)
   case imageGeneration(String)
 
   var errorDescription: String? {
     switch self {
-    case .invalidSchema(let message):
-      return "Invalid schema: \(message)"
     case .invalidMessage(let message), .invalidModel(let message), .imageGeneration(let message):
       return message
     }
@@ -1368,10 +1054,14 @@ private struct TextGenerationRequest: Record {
   @Field var id: String?
   @Field var system: String?
   @Field var prompt: String = ""
-  @Field var outputSchema: [String: Any]?
+  @Field var messages: [TextMessageRequest] = []
   @Field var temperature: Double?
   @Field var maxTokens: Int?
-  @Field var tools: [ToolDefinitionRequest] = []
+}
+
+private struct TextMessageRequest: Record {
+  @Field var role: String = ""
+  @Field var content: String = ""
 }
 
 private struct LocalTextGenerationRequest: Record {
@@ -1389,19 +1079,6 @@ private struct LocalTextGenerationRequest: Record {
   @Field var seed: Int?
 }
 
-private struct ToolDefinitionRequest: Record {
-  @Field var name: String = ""
-  @Field var description: String = ""
-  @Field var inputSchema: [String: Any] = [:]
-}
-
-private struct ToolResultRequest: Record {
-  @Field var generationId: String = ""
-  @Field var callId: String = ""
-  @Field var output: String?
-  @Field var error: String?
-}
-
 private struct ImageGenerationRequest: Record {
   @Field var model: String = ""
   @Field var prompt: String = ""

package/templates/state/app/index.tsx

@@ -1,6 +1,6 @@
+import { Button } from 'bleam/elements'
 import { atom, useAtom } from 'bleam/state'
 import { sx } from 'bleam/styles'
-import { Button } from 'bleam/ui'
 import { Window } from 'bleam/window'
 import { Text, View } from 'react-native'
 
@@ -20,7 +20,7 @@ export default function App() {
         </Text>
       ))}
       <Button
-        title="Add task"
+        label="Add task"
         onPress={() =>
           setItems((current) => [...current, `Task ${current.length + 1}`])
         }

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

@@ -1,55 +1,48 @@
-import { bonsai, prepareTextModel, stream } from 'bleam/ai'
+import { bonsai, chat, prepareTextModel, useChat, useChatList } from 'bleam/ai'
+import { Button } from 'bleam/elements'
 import { sx } from 'bleam/styles'
-import { Button } from 'bleam/ui'
 import { Window } from 'bleam/window'
-import { useRef, useState } from 'react'
+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 [prompt, setPrompt] = useState(
-    'Rewrite this note so it is clear and concise: We should probably meet sometime next week to discuss the launch.',
-  )
-  const [answer, setAnswer] = useState('Runs privately on this Mac.')
-  const [status, setStatus] = useState('Ready')
-  const [isRunning, setIsRunning] = useState(false)
-  const controller = useRef<AbortController>(null)
+  const chats = useChatList()
+  const creating = useRef(false)
+  const [path, setPath] = useState<string | null>(null)
+  const [status, setStatus] = useState('Preparing local model...')
 
-  async function run() {
-    if (controller.current) return
-    const nextController = new AbortController()
-    controller.current = nextController
-    setIsRunning(true)
-    setAnswer('')
+  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])
 
-    try {
-      await prepareTextModel(model, {
-        signal: nextController.signal,
-        onProgress(progress) {
-          setStatus(
-            `Preparing model ${Math.round(progress.modelFraction * 100)}%`,
-          )
-        },
+  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')
       })
-      setStatus('Generating')
-      for await (const text of stream({
-        model,
-        system: 'You are a concise private writing assistant.',
-        prompt,
-        signal: nextController.signal,
-      })) {
-        setAnswer(text)
-      }
-      setStatus('Complete')
-    } catch (error) {
-      setStatus(error instanceof Error ? error.message : String(error))
-    } finally {
-      if (controller.current === nextController) controller.current = null
-      setIsRunning(false)
-    }
-  }
+      .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')}>
@@ -58,14 +51,41 @@ export default function App() {
         Private Writing Assistant
       </Text>
       <Text style={sx('text-secondary-label')}>
-        Ternary Bonsai runs locally after its first model download.
+        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(
-          'min-h-32',
+          { minHeight: 128 },
           'rounded-xl',
           'border',
           'border-separator',
@@ -74,20 +94,31 @@ export default function App() {
       />
       <View style={sx('flex-row', 'gap-3')}>
         <Button
-          title="Generate"
-          loading={isRunning}
-          disabled={isRunning}
-          onPress={() => void run()}
+          label="Send"
+          loading={conversation.isGenerating}
+          disabled={!conversation.canSend}
+          onPress={() => void conversation.send(prompt)}
         />
         <Button
-          title="Cancel"
+          label="Cancel"
           variant="secondary"
-          disabled={!isRunning}
-          onPress={() => controller.current?.abort()}
+          disabled={!conversation.canCancel}
+          onPress={() => void conversation.cancel()}
         />
+        {retryable ? (
+          <Button
+            label="Retry"
+            variant="secondary"
+            onPress={() => void conversation.retry(retryable.id)}
+          />
+        ) : null}
       </View>
-      <Text style={sx('text-secondary-label')}>{status}</Text>
-      <Text style={sx('text-lg', 'text-label')}>{answer}</Text>
+      {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>
   )
 }