bleam 0.0.8 → 0.0.9

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

@@ -0,0 +1,1258 @@
+import CoreImage
+import CoreImage.CIFilterBuiltins
+import ExpoModulesCore
+import Foundation
+
+#if canImport(FoundationModels)
+import FoundationModels
+#endif
+
+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", "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
+    }
+
+    AsyncFunction("streamGenerate") { [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)
+            let stream = session.streamResponse(to: request.prompt, options: options)
+            var content = ""
+            for try await snapshot in stream {
+              try Task.checkCancellation()
+              content = snapshot.content
+              self.sendEvent("textGenerationUpdate", ["id": generationID, "content": content])
+            }
+            promise.resolve(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
+    }
+
+    AsyncFunction("cancelTextGeneration") { [weak self] (id: String) -> Bool in
+      await self?.textGeneration.cancel(id) ?? false
+    }
+
+    AsyncFunction("resolveToolCall") { [weak self] (request: ToolResultRequest) -> Bool in
+      await self?.textGeneration.resolve(request) ?? false
+    }
+
+    AsyncFunction("generateImage") { (request: ImageGenerationRequest, promise: Promise) in
+      do {
+        let imageRequest = try Self.imageRequest(from: request)
+        try Self.validateImageRequest(imageRequest)
+        let workerRequest = try Self.workerRequest(from: imageRequest)
+        Task { @MainActor in
+          do {
+            let event = try await ImageGenerationServiceClient.shared.run(
+              request: workerRequest,
+              onProgress: { [weak self] event in
+                guard let currentStep = event.currentStep, let totalSteps = event.totalSteps else { return }
+                self?.sendEvent("imagegenProgress", [
+                  "currentStep": currentStep,
+                  "totalSteps": totalSteps,
+                ])
+              }
+            )
+            guard let path = event.path, let width = event.width, let height = event.height, let model = event.model else {
+              throw ModuleError.imageGeneration("GenerationService returned an incomplete result")
+            }
+            var response: [String: Any] = [
+              "uri": URL(fileURLWithPath: path).absoluteString,
+              "width": width,
+              "height": height,
+              "model": model,
+            ]
+            if let metadata = Self.metadataDictionary(event.metadata) {
+              response["metadata"] = metadata
+            }
+            promise.resolve(response)
+          } catch {
+            Self.rejectImageGeneration(error, promise: promise)
+          }
+        }
+      } catch {
+        promise.reject(error)
+      }
+    }
+
+    AsyncFunction("cancelImagegen") { (promise: Promise) in
+      Task { @MainActor in
+        do {
+          promise.resolve(try await ImageGenerationServiceClient.shared.cancel())
+        } catch {
+          promise.reject(error)
+        }
+      }
+    }
+
+    AsyncFunction("imageMemoryTelemetry") { (promise: Promise) in
+      Task { @MainActor in
+        do {
+          promise.resolve(try await ImageGenerationServiceClient.shared.memoryTelemetry())
+        } catch {
+          promise.reject(error)
+        }
+      }
+    }
+
+    AsyncFunction("unloadImageModel") { (promise: Promise) in
+      Task { @MainActor in
+        do {
+          promise.resolve(try await ImageGenerationServiceClient.shared.unload())
+        } catch {
+          promise.reject(error)
+        }
+      }
+    }
+
+    AsyncFunction("upscaleImage") { (request: UpscaleImageRequest) throws -> [String: Any] in
+      guard request.scale > 1, request.scale <= 4, request.scale.isFinite else {
+        throw ModuleError.invalidModel("Upscale scale must be greater than 1 and at most 4")
+      }
+      let sourceURL = URL(fileURLWithPath: request.imagePath)
+      guard sourceURL.isFileURL, FileManager.default.fileExists(atPath: sourceURL.path) else {
+        throw ModuleError.invalidMessage("Upscale image does not exist")
+      }
+      guard let source = CIImage(contentsOf: sourceURL) else {
+        throw ModuleError.invalidMessage("Upscale image could not be decoded")
+      }
+      let width = Int((source.extent.width * request.scale).rounded())
+      let height = Int((source.extent.height * request.scale).rounded())
+      guard width > 0, height > 0, width <= 16_384, height <= 16_384 else {
+        throw ModuleError.invalidModel("Upscaled dimensions must not exceed 16384 pixels")
+      }
+
+      let filter = CIFilter.lanczosScaleTransform()
+      filter.inputImage = source
+      filter.scale = Float(request.scale)
+      filter.aspectRatio = 1
+      guard let output = filter.outputImage else {
+        throw ModuleError.imageGeneration("Image upscaling failed")
+      }
+
+      let directory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        .appendingPathComponent("Bleam/Upscaled", isDirectory: true)
+      try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+      let outputURL = directory.appendingPathComponent("\(UUID().uuidString.lowercased()).png")
+      let colorSpace = source.colorSpace ?? CGColorSpace(name: CGColorSpace.sRGB)!
+      try CIContext().writePNGRepresentation(
+        of: output,
+        to: outputURL,
+        format: .RGBA8,
+        colorSpace: colorSpace
+      )
+      return [
+        "uri": outputURL.absoluteString,
+        "width": width,
+        "height": height,
+        "scale": request.scale,
+      ]
+    }
+  }
+
+  private static func imageRequest(from request: ImageGenerationRequest) throws -> FluxImageRequest {
+    guard !request.model.isEmpty else {
+      throw ModuleError.invalidModel("Missing image model")
+    }
+    guard request.model == "flux2-klein-4b-8bit-abliterated" else {
+      throw ModuleError.invalidModel("Unsupported image model: \(request.model)")
+    }
+    guard !request.prompt.isEmpty else {
+      throw ModuleError.invalidMessage("Expected prompt")
+    }
+    if let sourceImagePath = request.sourceImagePath, sourceImagePath.isEmpty {
+      throw ModuleError.invalidMessage("Source image path must not be empty")
+    }
+    if let maskImagePath = request.maskImagePath, maskImagePath.isEmpty {
+      throw ModuleError.invalidMessage("Mask image path must not be empty")
+    }
+    if request.maskImagePath != nil, request.sourceImagePath == nil {
+      throw ModuleError.invalidMessage("Mask image requires a source image")
+    }
+    if let maskMode = request.maskMode, maskMode != "paint" && maskMode != "preserve" {
+      throw ModuleError.invalidModel("Mask mode must be paint or preserve")
+    }
+    if request.outpaintWidth != nil || request.outpaintHeight != nil || request.outpaintSourceX != nil || request.outpaintSourceY != nil || request.outpaintSourceWidth != nil || request.outpaintSourceHeight != nil {
+      guard request.sourceImagePath != nil else {
+        throw ModuleError.invalidMessage("Outpaint requires a source image")
+      }
+      guard let outpaintWidth = request.outpaintWidth, outpaintWidth > 0 else {
+        throw ModuleError.invalidModel("Invalid outpaint width")
+      }
+      guard let outpaintHeight = request.outpaintHeight, outpaintHeight > 0 else {
+        throw ModuleError.invalidModel("Invalid outpaint height")
+      }
+      guard let sourceX = request.outpaintSourceX,
+        let sourceY = request.outpaintSourceY,
+        let sourceWidth = request.outpaintSourceWidth, sourceWidth > 0,
+        let sourceHeight = request.outpaintSourceHeight, sourceHeight > 0
+      else {
+        throw ModuleError.invalidModel("Outpaint requires a valid source rect")
+      }
+      guard sourceX < outpaintWidth, sourceY < outpaintHeight,
+        sourceX + sourceWidth > 0, sourceY + sourceHeight > 0
+      else {
+        throw ModuleError.invalidModel("Outpaint source rect must intersect the canvas")
+      }
+      if request.outpaintAutoCrop != true,
+        (sourceX < 0 || sourceY < 0 || sourceX + sourceWidth > outpaintWidth || sourceY + sourceHeight > outpaintHeight)
+      {
+        throw ModuleError.invalidModel("Outpaint source rect must fit within the canvas unless autoCrop is enabled")
+      }
+    }
+    if let resizeMode = request.resizeMode, !["stretch", "fit", "crop"].contains(resizeMode) {
+      throw ModuleError.invalidModel("Resize mode must be stretch, fit, or crop")
+    }
+    if let maxInputLongSide = request.maxInputLongSide, maxInputLongSide != 0 && maxInputLongSide < 64 {
+      throw ModuleError.invalidModel("maxInputLongSide must be 0 or at least 64")
+    }
+    guard request.referenceImagePaths.allSatisfy({ !$0.isEmpty }) else {
+      throw ModuleError.invalidMessage("Reference image paths must not be empty")
+    }
+    guard request.referenceImagePaths.count <= 3 else {
+      throw ModuleError.invalidModel("Expected at most 3 reference images")
+    }
+    if let referenceInfluences = request.referenceInfluences {
+      guard referenceInfluences.count == request.referenceImagePaths.count else {
+        throw ModuleError.invalidModel("Reference influences must match reference image count")
+      }
+      guard referenceInfluences.allSatisfy({ $0.isFinite && $0 >= 0 }) else {
+        throw ModuleError.invalidModel("Reference influences must be non-negative numbers")
+      }
+    }
+    guard request.loraPaths.allSatisfy({ !$0.isEmpty }) else {
+      throw ModuleError.invalidMessage("LoRA paths must not be empty")
+    }
+    if let loraScales = request.loraScales {
+      guard loraScales.count == request.loraPaths.count else {
+        throw ModuleError.invalidModel("LoRA scales must match LoRA path count")
+      }
+      guard loraScales.allSatisfy({ $0.isFinite && $0 > 0 }) else {
+        throw ModuleError.invalidModel("LoRA scales must be positive numbers")
+      }
+    }
+    if let loraIds = request.loraIds {
+      guard loraIds.count == request.loraPaths.count else {
+        throw ModuleError.invalidModel("LoRA ids must match LoRA path count")
+      }
+    }
+    guard !request.modelRoot.isEmpty else {
+      throw ModuleError.invalidModel("Missing model root")
+    }
+    guard !request.textEncoderPath.isEmpty else {
+      throw ModuleError.invalidModel("Missing text encoder path")
+    }
+    guard !request.transformerPath.isEmpty else {
+      throw ModuleError.invalidModel("Missing transformer path")
+    }
+    guard !request.vaePath.isEmpty else {
+      throw ModuleError.invalidModel("Missing VAE path")
+    }
+    guard request.width > 0 else {
+      throw ModuleError.invalidModel("Invalid image width")
+    }
+    guard request.height > 0 else {
+      throw ModuleError.invalidModel("Invalid image height")
+    }
+    guard request.steps > 0 else {
+      throw ModuleError.invalidModel("Invalid image steps")
+    }
+    guard request.guidance > 0 else {
+      throw ModuleError.invalidModel("Invalid image guidance")
+    }
+    if let strength = request.strength, !(strength > 0 && strength <= 1) {
+      throw ModuleError.invalidModel("Image strength must be greater than 0 and at most 1")
+    }
+    guard !request.inputIds.isEmpty else {
+      throw ModuleError.invalidMessage("Missing tokenized input ids")
+    }
+    guard request.attentionMask.count == request.inputIds.count else {
+      throw ModuleError.invalidMessage("Attention mask must match input ids")
+    }
+
+    return FluxImageRequest(
+      model: request.model,
+      prompt: request.prompt,
+      sourceImagePath: request.sourceImagePath,
+      maskImagePath: request.maskImagePath,
+      maskMode: request.maskMode,
+      outpaintWidth: request.outpaintWidth,
+      outpaintHeight: request.outpaintHeight,
+      outpaintSourceX: request.outpaintSourceX,
+      outpaintSourceY: request.outpaintSourceY,
+      outpaintSourceWidth: request.outpaintSourceWidth,
+      outpaintSourceHeight: request.outpaintSourceHeight,
+      outpaintAutoCrop: request.outpaintAutoCrop,
+      resizeMode: request.resizeMode,
+      maxInputLongSide: request.maxInputLongSide,
+      referenceImagePaths: request.referenceImagePaths,
+      referenceInfluences: request.referenceInfluences,
+      loraPaths: request.loraPaths,
+      loraScales: request.loraScales,
+      loraIds: request.loraIds,
+      sigmaSchedule: request.sigmaSchedule,
+      width: request.width,
+      height: request.height,
+      steps: request.steps,
+      guidance: request.guidance,
+      strength: request.strength,
+      seed: request.seed,
+      inputIds: request.inputIds,
+      attentionMask: request.attentionMask,
+      modelRoot: request.modelRoot,
+      textEncoderPath: request.textEncoderPath,
+      transformerPath: request.transformerPath,
+      vaePath: request.vaePath
+    )
+  }
+
+  private static func validateImageRequest(_ request: FluxImageRequest) throws {
+    let fileManager = FileManager.default
+    for path in [request.modelRoot, request.textEncoderPath, request.transformerPath, request.vaePath] {
+      var isDirectory: ObjCBool = false
+      guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory), isDirectory.boolValue else {
+        throw ModuleError.invalidModel("Missing model directory: \(path)")
+      }
+    }
+
+    for path in [request.sourceImagePath, request.maskImagePath].compactMap({ $0 }) + request.referenceImagePaths + request.loraPaths {
+      var isDirectory: ObjCBool = false
+      guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory), !isDirectory.boolValue else {
+        throw ModuleError.invalidMessage("Missing image file: \(path)")
+      }
+    }
+  }
+
+  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")
+    }
+
+    let stagingDirectory = appGroupContainer
+      .appendingPathComponent("GenerationRuns", isDirectory: true)
+      .appendingPathComponent("bleam-generation-jobs", isDirectory: true)
+      .appendingPathComponent(jobID.uuidString, isDirectory: true)
+    try FileManager.default.createDirectory(at: stagingDirectory, withIntermediateDirectories: true)
+
+    return GenerationWorkerRequest(
+      jobID: jobID,
+      model: request.model,
+      prompt: request.prompt,
+      sourceImagePath: request.sourceImagePath,
+      maskImagePath: request.maskImagePath,
+      maskMode: request.maskMode,
+      outpaintWidth: request.outpaintWidth,
+      outpaintHeight: request.outpaintHeight,
+      outpaintSourceX: request.outpaintSourceX,
+      outpaintSourceY: request.outpaintSourceY,
+      outpaintSourceWidth: request.outpaintSourceWidth,
+      outpaintSourceHeight: request.outpaintSourceHeight,
+      outpaintAutoCrop: request.outpaintAutoCrop,
+      resizeMode: request.resizeMode,
+      maxInputLongSide: request.maxInputLongSide,
+      referenceImagePaths: request.referenceImagePaths,
+      referenceInfluences: request.referenceInfluences,
+      loraPaths: request.loraPaths,
+      loraScales: request.loraScales,
+      loraIds: request.loraIds,
+      sigmaSchedule: request.sigmaSchedule,
+      width: request.width,
+      height: request.height,
+      steps: request.steps,
+      guidance: request.guidance,
+      strength: request.strength,
+      seed: request.seed,
+      inputIds: request.inputIds,
+      attentionMask: request.attentionMask,
+      modelRoot: request.modelRoot,
+      textEncoderPath: request.textEncoderPath,
+      transformerPath: request.transformerPath,
+      vaePath: request.vaePath,
+      stagingDirectoryPath: stagingDirectory.path
+    )
+  }
+
+  private static func metadataDictionary(_ metadata: GenerationWorkerMetadata?) -> [String: Any]? {
+    guard let metadata else { return nil }
+    var value: [String: Any] = [
+      "model": metadata.model,
+      "width": metadata.width,
+      "height": metadata.height,
+      "steps": metadata.steps,
+      "guidance": metadata.guidance,
+      "elapsedMs": metadata.elapsedMs,
+    ]
+    if let strength = metadata.strength { value["strength"] = strength }
+    if let seed = metadata.seed { value["seed"] = seed }
+    if let appliedLoRAs = metadata.appliedLoRAs {
+      value["appliedLoRAs"] = appliedLoRAs.map { lora in
+        var item: [String: Any] = [
+          "path": lora.path,
+          "scale": lora.scale,
+        ]
+        if let id = lora.id { item["id"] = id }
+        return item
+      }
+    }
+    if let sigmaSchedule = metadata.sigmaSchedule {
+      value["sigmaSchedule"] = sigmaSchedule
+    }
+    return value
+  }
+
+  private static func rejectImageGeneration(_ error: Error, promise: Promise) {
+    if let failure = error as? GenerationWorkerFailure {
+      let message = failure.stage.map { "[\($0)] \(failure.message)" } ?? failure.message
+      promise.reject("IMAGE_GENERATION_ERROR", message)
+      return
+    }
+    promise.reject(error)
+  }
+
+#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)
+    }
+    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
+      )
+    }
+  }
+
+  @available(iOS 26, *)
+  private static func generationOptions(from request: TextGenerationRequest) throws -> GenerationOptions {
+    return GenerationOptions(
+      sampling: request.temperature == nil ? .greedy : nil,
+      temperature: request.temperature,
+      maximumResponseTokens: request.maxTokens
+    )
+  }
+
+  @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 {
+      promise.reject("GENERATION_CANCELED", "Generation canceled")
+      return
+    }
+    if let generationError = error as? LanguageModelSession.GenerationError {
+      switch generationError {
+      case .exceededContextWindowSize:
+        promise.reject("CONTEXT_WINDOW_EXCEEDED", error.localizedDescription)
+      case .concurrentRequests:
+        promise.reject("CONCURRENT_REQUEST", error.localizedDescription)
+      case .guardrailViolation:
+        promise.reject("GUARDRAIL_VIOLATION", error.localizedDescription)
+      case .unsupportedLanguageOrLocale:
+        promise.reject("UNSUPPORTED_LANGUAGE_OR_LOCALE", error.localizedDescription)
+      case .rateLimited:
+        promise.reject("RATE_LIMITED", error.localizedDescription)
+      default:
+        promise.reject("GENERATION_ERROR", error.localizedDescription)
+      }
+      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()
+    tasks[id] = task
+  }
+
+  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
+    }
+  }
+}
+
+@MainActor
+private final class ImageGenerationServiceClient {
+  static let shared = ImageGenerationServiceClient()
+
+  private static var serviceName: String {
+    "\(Bundle.main.bundleIdentifier ?? "dev.bleam.app").GenerationService"
+  }
+  private var connection: NSXPCConnection?
+  private var pendingRun: PendingRun?
+  private let eventReceiver = GenerationServiceEventReceiver()
+
+  private final class PendingRun {
+    let continuation: CheckedContinuation<GenerationWorkerEvent, Error>
+    let onProgress: (GenerationWorkerEvent) -> Void
+
+    init(
+      continuation: CheckedContinuation<GenerationWorkerEvent, Error>,
+      onProgress: @escaping (GenerationWorkerEvent) -> Void
+    ) {
+      self.continuation = continuation
+      self.onProgress = onProgress
+    }
+  }
+
+  func run(
+    request: GenerationWorkerRequest,
+    onProgress: @escaping (GenerationWorkerEvent) -> Void = { _ in }
+  ) async throws -> GenerationWorkerEvent {
+    let terminalEvent: GenerationWorkerEvent = try await withCheckedThrowingContinuation { continuation in
+      do {
+        guard pendingRun == nil else {
+          continuation.resume(throwing: GenerationServiceClientError.concurrentRequest)
+          return
+        }
+
+        eventReceiver.onEvent = { [weak self] event in
+          self?.deliver(event)
+        }
+        pendingRun = PendingRun(continuation: continuation, onProgress: onProgress)
+
+        let requestData = try JSONEncoder().encode(request)
+        let service = try remoteProxy(errorHandler: { [weak self] error in
+          Task { @MainActor in
+            self?.failPendingRun(Self.mapConnectionError(error))
+          }
+        })
+        service.startGeneration(requestData: requestData) { [weak self] accepted in
+          Task { @MainActor in
+            guard accepted else {
+              self?.failPendingRun(GenerationServiceClientError.serviceUnavailable)
+              return
+            }
+          }
+        }
+      } catch {
+        pendingRun = nil
+        eventReceiver.onEvent = nil
+        continuation.resume(throwing: error)
+      }
+    }
+
+    try handleTerminalEvent(terminalEvent)
+    return terminalEvent
+  }
+
+  func cancel() async throws -> Bool {
+    guard pendingRun != nil else {
+      return false
+    }
+
+    let service = try remoteProxy(errorHandler: { [weak self] error in
+      Task { @MainActor in
+        self?.failPendingRun(Self.mapConnectionError(error))
+      }
+    })
+
+    return try await withCheckedThrowingContinuation { continuation in
+      service.cancelGeneration { canceled in
+        continuation.resume(returning: canceled)
+      }
+    }
+  }
+
+  func memoryTelemetry() async throws -> [String: Any] {
+    let service = try remoteProxy(errorHandler: { _ in })
+    return try await withCheckedThrowingContinuation { continuation in
+      service.memoryTelemetry { data in
+        guard
+          let data,
+          let value = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+          continuation.resume(throwing: GenerationServiceClientError.serviceUnavailable)
+          return
+        }
+        continuation.resume(returning: value)
+      }
+    }
+  }
+
+  func unload() async throws -> Bool {
+    guard pendingRun == nil else { return false }
+    let service = try remoteProxy(errorHandler: { _ in })
+    let unloaded = try await withCheckedThrowingContinuation { continuation in
+      service.shutdown { accepted in
+        continuation.resume(returning: accepted)
+      }
+    }
+    if unloaded {
+      connection?.invalidate()
+      connection = nil
+    }
+    return unloaded
+  }
+
+  private func remoteProxy(errorHandler: @escaping (Error) -> Void) throws -> GenerationServiceProtocol {
+    if connection == nil {
+      let nextConnection = try Self.makeConnection(serviceName: Self.serviceName)
+      nextConnection.remoteObjectInterface = NSXPCInterface(with: GenerationServiceProtocol.self)
+      nextConnection.exportedInterface = NSXPCInterface(with: GenerationServiceClientProtocol.self)
+      nextConnection.exportedObject = eventReceiver
+      nextConnection.invalidationHandler = { [weak self] in
+        Task { @MainActor in self?.handleConnectionLost() }
+      }
+      nextConnection.interruptionHandler = { [weak self] in
+        Task { @MainActor in self?.handleConnectionLost() }
+      }
+      nextConnection.resume()
+      connection = nextConnection
+    }
+
+    guard let service = connection?.remoteObjectProxyWithErrorHandler(errorHandler) as? GenerationServiceProtocol else {
+      throw GenerationServiceClientError.serviceUnavailable
+    }
+    return service
+  }
+
+  private static func makeConnection(serviceName: String) throws -> NSXPCConnection {
+#if targetEnvironment(macCatalyst)
+    let connectionClass: AnyObject = NSXPCConnection.self as AnyObject
+    let allocSelector = NSSelectorFromString("alloc")
+    let initSelector = NSSelectorFromString("initWithServiceName:")
+
+    guard
+      let allocated = connectionClass.perform(allocSelector)?.takeUnretainedValue() as AnyObject?,
+      allocated.responds(to: initSelector),
+      let connection = allocated.perform(initSelector, with: serviceName)?.takeUnretainedValue() as? NSXPCConnection
+    else {
+      throw GenerationServiceClientError.serviceUnavailable
+    }
+
+    return connection
+#else
+    return NSXPCConnection(serviceName: serviceName)
+#endif
+  }
+
+  private func deliver(_ event: GenerationWorkerEvent) {
+    if event.type == .log {
+      DevLogPoster.post(
+        source: "xpc",
+        level: event.level ?? "info",
+        category: event.category,
+        message: event.message ?? "",
+        jobID: event.jobID
+      )
+      return
+    }
+
+    guard let pendingRun else {
+      print("[GenerationServiceClient] event without pending request type=\(event.type.rawValue)")
+      return
+    }
+
+    if event.type == .progress {
+      pendingRun.onProgress(event)
+      return
+    }
+
+    if event.type == .completed || event.type == .canceled || event.type == .failed {
+      self.pendingRun = nil
+      eventReceiver.onEvent = nil
+      pendingRun.continuation.resume(returning: event)
+    }
+  }
+
+  private func failPendingRun(_ error: Error) {
+    guard let pendingRun else { return }
+    self.pendingRun = nil
+    eventReceiver.onEvent = nil
+    if GenerationServiceClientError.isServiceKilledInsufficientMemory(error) {
+      invalidate()
+    }
+    pendingRun.continuation.resume(throwing: error)
+  }
+
+  private func handleConnectionLost() {
+    connection = nil
+    failPendingRun(GenerationServiceClientError.serviceInterrupted)
+  }
+
+  private func invalidate() {
+    connection?.invalidate()
+    connection = nil
+  }
+
+  private func handleTerminalEvent(_ event: GenerationWorkerEvent) throws {
+    switch event.type {
+    case .completed:
+      return
+    case .canceled:
+      throw CancellationError()
+    case .failed:
+      throw GenerationWorkerFailure(message: event.message ?? "Generation failed.", stage: event.stage)
+    default:
+      throw GenerationServiceClientError.invalidResponse
+    }
+  }
+
+  private static func mapConnectionError(_ error: Error) -> Error {
+    let nsError = error as NSError
+    if nsError.domain == NSCocoaErrorDomain || nsError.domain.localizedCaseInsensitiveContains("xpc") {
+      return GenerationServiceClientError.serviceInterrupted
+    }
+    return error
+  }
+}
+
+private enum DevLogPoster {
+  static func post(source: String, level: String, category: String?, message: String, jobID: String? = nil) {
+    Task.detached {
+      guard let config = try? loadProjectConfig(), let devServer = config["devServer"] as? String else {
+        return
+      }
+      guard let url = URL(string: "\(devServer)/bleam/logs") else {
+        return
+      }
+
+      var payload: [String: Any] = [
+        "source": source,
+        "level": level,
+        "message": message,
+      ]
+      if let category { payload["category"] = category }
+      if let jobID { payload["jobId"] = jobID }
+
+      guard let body = try? JSONSerialization.data(withJSONObject: payload) else {
+        return
+      }
+      var request = URLRequest(url: url)
+      request.httpMethod = "POST"
+      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+      request.httpBody = body
+      _ = try? await URLSession.shared.data(for: request)
+    }
+  }
+
+  private static func loadProjectConfig() throws -> [String: Any]? {
+    guard let configPath = projectConfigPath() else {
+      return nil
+    }
+
+    let data = try Data(contentsOf: URL(fileURLWithPath: configPath))
+    return try JSONSerialization.jsonObject(with: data) as? [String: Any]
+  }
+
+  private static func projectConfigPath() -> String? {
+    let arguments = ProcessInfo.processInfo.arguments
+    guard let flagIndex = arguments.firstIndex(of: "--bleam-project-config") else {
+      return nil
+    }
+
+    let valueIndex = arguments.index(after: flagIndex)
+    guard arguments.indices.contains(valueIndex) else {
+      return nil
+    }
+
+    return arguments[valueIndex]
+  }
+}
+
+private enum GenerationServiceClientError: LocalizedError, Equatable {
+  case serviceUnavailable
+  case invalidResponse
+  case serviceInterrupted
+  case serviceKilledInsufficientMemory
+  case concurrentRequest
+
+  static func isServiceKilledInsufficientMemory(_ error: Error) -> Bool {
+    guard let clientError = error as? GenerationServiceClientError else { return false }
+    return clientError == .serviceKilledInsufficientMemory
+  }
+
+  var errorDescription: String? {
+    switch self {
+    case .serviceUnavailable:
+      return "GenerationService is unavailable."
+    case .invalidResponse:
+      return "GenerationService returned an invalid response."
+    case .serviceInterrupted:
+      return "GenerationService was interrupted."
+    case .serviceKilledInsufficientMemory:
+      return "Generation failed because there was not enough available memory."
+    case .concurrentRequest:
+      return "GenerationService is already running a request."
+    }
+  }
+}
+
+private final class GenerationServiceEventReceiver: NSObject, GenerationServiceClientProtocol {
+  @MainActor var onEvent: ((GenerationWorkerEvent) -> Void)?
+
+  func generationWorkerDidEmit(eventData: Data) {
+    guard let event = try? JSONDecoder().decode(GenerationWorkerEvent.self, from: eventData) else { return }
+    Task { @MainActor in
+      onEvent?(event)
+    }
+  }
+}
+
+private struct TextGenerationRequest: Record {
+  @Field var id: String?
+  @Field var system: String?
+  @Field var prompt: String = ""
+  @Field var outputSchema: [String: Any]?
+  @Field var temperature: Double?
+  @Field var maxTokens: Int?
+  @Field var tools: [ToolDefinitionRequest] = []
+}
+
+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 = ""
+  @Field var sourceImagePath: String?
+  @Field var maskImagePath: String?
+  @Field var maskMode: String?
+  @Field var outpaintWidth: Int?
+  @Field var outpaintHeight: Int?
+  @Field var outpaintSourceX: Int?
+  @Field var outpaintSourceY: Int?
+  @Field var outpaintSourceWidth: Int?
+  @Field var outpaintSourceHeight: Int?
+  @Field var outpaintAutoCrop: Bool?
+  @Field var resizeMode: String?
+  @Field var maxInputLongSide: Int?
+  @Field var referenceImagePaths: [String] = []
+  @Field var referenceInfluences: [Double]?
+  @Field var loraPaths: [String] = []
+  @Field var loraScales: [Double]?
+  @Field var loraIds: [String]?
+  @Field var sigmaSchedule: [Double]?
+  @Field var width: Int = 0
+  @Field var height: Int = 0
+  @Field var steps: Int = 0
+  @Field var guidance: Double = 0
+  @Field var strength: Double?
+  @Field var seed: Int?
+  @Field var inputIds: [Int] = []
+  @Field var attentionMask: [Int] = []
+  @Field var modelRoot: String = ""
+  @Field var textEncoderPath: String = ""
+  @Field var transformerPath: String = ""
+  @Field var vaePath: String = ""
+}
+
+private struct UpscaleImageRequest: Record {
+  @Field var imagePath: String = ""
+  @Field var scale: Double = 2
+}
+
+private struct FluxImageRequest {
+  let model: String
+  let prompt: String
+  let sourceImagePath: String?
+  let maskImagePath: String?
+  let maskMode: String?
+  let outpaintWidth: Int?
+  let outpaintHeight: Int?
+  let outpaintSourceX: Int?
+  let outpaintSourceY: Int?
+  let outpaintSourceWidth: Int?
+  let outpaintSourceHeight: Int?
+  let outpaintAutoCrop: Bool?
+  let resizeMode: String?
+  let maxInputLongSide: Int?
+  let referenceImagePaths: [String]
+  let referenceInfluences: [Double]?
+  let loraPaths: [String]
+  let loraScales: [Double]?
+  let loraIds: [String]?
+  let sigmaSchedule: [Double]?
+  let width: Int
+  let height: Int
+  let steps: Int
+  let guidance: Double
+  let strength: Double?
+  let seed: Int?
+  let inputIds: [Int]
+  let attentionMask: [Int]
+  let modelRoot: String
+  let textEncoderPath: String
+  let transformerPath: String
+  let vaePath: String
+}