@independo/capacitor-inderun 0.2.0-dev.0

package/dist/web.js

@@ -0,0 +1,52 @@
+import { WebPlugin } from "@capacitor/core";
+import { createIndeRunWeb, createUnavailable, toIndeRunException } from "@independo/inderun-web";
+export class IndeRunWeb extends WebPlugin {
+    engine = null;
+    async configure(options) {
+        if (!options?.openAI) {
+            throw createUnavailable("Capacitor web execution requires OpenAI provider registration. Configure with openAI bootstrap options before calling run(request).").toContractError();
+        }
+        try {
+            const webOptions = {
+                openAI: compactOpenAIOptions(options)
+            };
+            if (options.allowDirectOpenAIEndpoint !== undefined) {
+                webOptions.allowDirectOpenAIEndpoint = options.allowDirectOpenAIEndpoint;
+            }
+            this.engine = createIndeRunWeb(webOptions);
+        }
+        catch (error) {
+            throw toIndeRunException(error).toContractError();
+        }
+    }
+    async run(request) {
+        if (!this.engine) {
+            throw createUnavailable("Capacitor IndeRun has not been configured. Configure providers before calling run(request).").toContractError();
+        }
+        try {
+            return await this.engine.run(request);
+        }
+        catch (error) {
+            throw toIndeRunException(error).toContractError();
+        }
+    }
+}
+function compactOpenAIOptions(options) {
+    const openAI = options.openAI;
+    const result = {
+        model: openAI.model
+    };
+    if (openAI.endpointUrl !== undefined) {
+        result.endpointUrl = openAI.endpointUrl;
+    }
+    if (openAI.auth !== undefined) {
+        result.auth = openAI.auth;
+    }
+    if (openAI.authContextRef !== undefined) {
+        result.authContextRef = openAI.authContextRef;
+    }
+    if (openAI.timeoutMs !== undefined) {
+        result.timeoutMs = openAI.timeoutMs;
+    }
+    return result;
+}

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorBridge.swift

@@ -0,0 +1,105 @@
+#if canImport(Capacitor)
+import Capacitor
+#else
+typealias JSObject = [String: Any]
+#endif
+import Foundation
+import IndeRunAppleProviders
+import IndeRunCore
+import IndeRunContracts
+import IndeRunOpenAIProviders
+import IndeRunSwift
+
+struct OpenAIProviderBootstrapOptions: Codable {
+    let model: String
+    let endpointURL: String?
+    let auth: String?
+    let authContextRef: String?
+    let timeoutMs: Int?
+}
+
+struct CapacitorRunOptions: Codable {
+    let openAI: OpenAIProviderBootstrapOptions?
+    let allowDirectOpenAIEndpoint: Bool? // web-only, no-op on native
+}
+
+final class IndeRunCapacitorBridge {
+    private var configuredRegistry: ProviderRegistry?
+    private var configuredHostServices: HostServices?
+
+    func configure(options: JSObject) throws {
+        let runOptions = try decodeConfigureOptions(from: options)
+        configuredRegistry = try makeRegistry(openAI: runOptions.openAI)
+        configuredHostServices = DefaultHostServices.make()
+    }
+
+    func run(requestObject: JSObject) async throws -> JSObject {
+        guard let registry = configuredRegistry, let hostServices = configuredHostServices else {
+            throw createUnavailable(message: "Capacitor IndeRun has not been configured. Configure providers before calling run(request).")
+        }
+
+        let request = try decodeRequest(from: requestObject)
+        // IndeRun is a stateless coordinator; new per call is intentional — registry is cached above.
+        let engine = IndeRun(registry: registry, hostServices: hostServices)
+        let result = try await engine.run(request: request)
+        return try encode(result)
+    }
+
+    func encode(error: IndeRunError) throws -> JSObject {
+        try encodeObject(error)
+    }
+
+    private func makeRegistry(openAI: OpenAIProviderBootstrapOptions?) throws -> ProviderRegistry {
+        let registry = ProviderRegistry()
+        try registry.register(AppleFoundationModelsProvider())
+
+        if let openAI {
+            try registry.register(
+                OpenAIProvider(
+                    options: OpenAIProviderOptions(
+                        id: "openai",
+                        model: openAI.model,
+                        endpointURL: openAI.endpointURL ?? defaultOpenAIResponsesEndpoint,
+                        auth: mapAuthMode(openAI.auth),
+                        authContextRef: openAI.authContextRef,
+                        timeoutMs: openAI.timeoutMs
+                    )
+                )
+            )
+        }
+
+        return registry
+    }
+
+    private func decodeConfigureOptions(from object: JSObject) throws -> CapacitorRunOptions {
+        let data = try JSONSerialization.data(withJSONObject: object, options: [])
+        return try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+    }
+
+    private func decodeRequest(from object: JSObject) throws -> TaskRequest {
+        let data = try JSONSerialization.data(withJSONObject: object, options: [])
+        return try JSONDecoder().decode(TaskRequest.self, from: data)
+    }
+
+    private func encode(_ result: TaskResult) throws -> JSObject {
+        try encodeObject(result)
+    }
+
+    private func encodeObject<T: Encodable>(_ value: T) throws -> JSObject {
+        let data = try JSONEncoder().encode(value)
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        guard let dictionary = object as? JSObject else {
+            throw createInternal(message: "Capacitor bridge failed to encode a JSON object.")
+        }
+        return dictionary
+    }
+
+    func mapAuthMode(_ value: String?) -> OpenAIAuthMode {
+        switch value {
+        case "none":
+            return .none
+        default:
+            return .authContextRef
+        }
+    }
+}

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorPlugin.swift

@@ -0,0 +1,51 @@
+#if canImport(Capacitor)
+import Capacitor
+import Foundation
+import IndeRunCore
+
+@objc(IndeRunCapacitorPlugin)
+public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "IndeRunCapacitorPlugin"
+    public let jsName = "IndeRunCapacitor"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "configure", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "run", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let implementation = IndeRunCapacitorBridge()
+
+    @objc func configure(_ call: CAPPluginCall) {
+        do {
+            try implementation.configure(options: call.options)
+            call.resolve()
+        } catch let error as IndeRunException {
+            let contractError = error.toContractError()
+            let details = try? implementation.encode(error: contractError)
+            call.reject(contractError.message, contractError.errorClass.rawValue, error, details)
+        } catch {
+            let normalized = toIndeRunException(error)
+            let contractError = normalized.toContractError()
+            let details = try? implementation.encode(error: contractError)
+            call.reject(contractError.message, contractError.errorClass.rawValue, normalized, details)
+        }
+    }
+
+    @objc func run(_ call: CAPPluginCall) {
+        Task {
+            do {
+                let result = try await implementation.run(requestObject: call.options)
+                call.resolve(result)
+            } catch let error as IndeRunException {
+                let contractError = error.toContractError()
+                let details = try? implementation.encode(error: contractError)
+                call.reject(contractError.message, contractError.errorClass.rawValue, error, details)
+            } catch {
+                let normalized = toIndeRunException(error)
+                let contractError = normalized.toContractError()
+                let details = try? implementation.encode(error: contractError)
+                call.reject(contractError.message, contractError.errorClass.rawValue, normalized, details)
+            }
+        }
+    }
+}
+#endif

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorBridgeTests.swift

@@ -0,0 +1,123 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+@testable import IndeRunCapacitorPlugin
+
+final class IndeRunCapacitorBridgeTests: XCTestCase {
+
+    // MARK: - CapacitorRunOptions decoding
+
+    func testDecodesConfigureOptionsWithOpenAI() throws {
+        let json: [String: Any] = [
+            "openAI": [
+                "model": "gpt-5.2",
+                "endpointURL": "/api/inderun/openai-responses",
+                "auth": "none",
+                "authContextRef": "openai/main",
+                "timeoutMs": 30_000
+            ]
+        ]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.openAI?.model, "gpt-5.2")
+        XCTAssertEqual(options.openAI?.endpointURL, "/api/inderun/openai-responses")
+        XCTAssertEqual(options.openAI?.auth, "none")
+        XCTAssertEqual(options.openAI?.authContextRef, "openai/main")
+        XCTAssertEqual(options.openAI?.timeoutMs, 30_000)
+        XCTAssertNil(options.allowDirectOpenAIEndpoint)
+    }
+
+    func testDecodesConfigureOptionsWithAllOptionalFieldsAbsent() throws {
+        let data = try JSONSerialization.data(withJSONObject: [String: Any]())
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertNil(options.openAI)
+        XCTAssertNil(options.allowDirectOpenAIEndpoint)
+    }
+
+    func testDecodesOpenAIOptionsWithOnlyRequiredFields() throws {
+        let json: [String: Any] = ["openAI": ["model": "gpt-4"]]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.openAI?.model, "gpt-4")
+        XCTAssertNil(options.openAI?.endpointURL)
+        XCTAssertNil(options.openAI?.auth)
+        XCTAssertNil(options.openAI?.authContextRef)
+        XCTAssertNil(options.openAI?.timeoutMs)
+    }
+
+    func testDecodesAllowDirectOpenAIEndpoint() throws {
+        let json: [String: Any] = ["allowDirectOpenAIEndpoint": true]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.allowDirectOpenAIEndpoint, true)
+    }
+
+    // MARK: - encode(error:)
+
+    func testEncodesIndeRunErrorRequiredFieldsOnly() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: nil,
+            errorClass: .Unavailable,
+            message: "Not configured.",
+            providerId: nil,
+            retryable: nil,
+            retryAfterMs: nil,
+            runId: nil,
+            schemaVersion: .the10
+        )
+
+        let encoded = try bridge.encode(error: error)
+
+        XCTAssertEqual(encoded["schemaVersion"] as? String, "1.0")
+        XCTAssertEqual(encoded["errorClass"] as? String, "Unavailable")
+        XCTAssertEqual(encoded["message"] as? String, "Not configured.")
+        XCTAssertNil(encoded["providerId"])
+        XCTAssertNil(encoded["retryable"])
+        XCTAssertNil(encoded["retryAfterMs"])
+        XCTAssertNil(encoded["runId"])
+    }
+
+    func testEncodesIndeRunErrorWithAllOptionalFields() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: nil,
+            errorClass: .RateLimited,
+            message: "Too many requests.",
+            providerId: "openai",
+            retryable: true,
+            retryAfterMs: 2_000,
+            runId: "run_abc",
+            schemaVersion: .the10
+        )
+
+        let encoded = try bridge.encode(error: error)
+
+        XCTAssertEqual(encoded["errorClass"] as? String, "RateLimited")
+        XCTAssertEqual(encoded["providerId"] as? String, "openai")
+        XCTAssertEqual(encoded["retryable"] as? Bool, true)
+        XCTAssertEqual(encoded["retryAfterMs"] as? Int, 2_000)
+        XCTAssertEqual(encoded["runId"] as? String, "run_abc")
+    }
+
+    // MARK: - mapAuthMode
+
+    func testMapAuthModeNoneString() {
+        let bridge = IndeRunCapacitorBridge()
+        XCTAssertEqual(bridge.mapAuthMode("none"), .none)
+    }
+
+    func testMapAuthModeUnknownStringDefaultsToAuthContextRef() {
+        let bridge = IndeRunCapacitorBridge()
+        XCTAssertEqual(bridge.mapAuthMode("some_future_value"), .authContextRef)
+    }
+
+    func testMapAuthModeNilDefaultsToAuthContextRef() {
+        let bridge = IndeRunCapacitorBridge()
+        XCTAssertEqual(bridge.mapAuthMode(nil), .authContextRef)
+    }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@independo/capacitor-inderun",
+  "version": "0.2.0-dev.0",
+  "description": "Thin Capacitor bridge for IndeRun across web, iOS, and Android.",
+  "license": "MIT",
+  "homepage": "https://github.com/independo-gmbh/capacitor-inderun#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/independo-gmbh/capacitor-inderun.git"
+  },
+  "bugs": {
+    "url": "https://github.com/independo-gmbh/capacitor-inderun/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "inderun",
+    "ai"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "android",
+    "ios",
+    "Package.swift",
+    "README.md"
+  ],
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "pnpm run build",
+    "lint": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "test:web": "vitest run",
+    "test:android": "cd android && ./gradlew :testDebugUnitTest",
+    "test:ios": "swift test",
+    "verify:web": "tsc -p tsconfig.json",
+    "verify:android": "cd android && ./gradlew assembleDebug",
+    "verify:ios": "swift build"
+  },
+  "dependencies": {
+    "@capacitor/core": "^8.0.0",
+    "@independo/inderun-contracts": "^0.2.0",
+    "@independo/inderun-web": "^0.2.0"
+  },
+  "devDependencies": {
+    "@saithodev/semantic-release-backmerge": "^4.0.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^24.13.2",
+    "conventional-changelog-conventionalcommits": "^9.3.1",
+    "semantic-release": "^25.0.5",
+    "typescript": "^6.0.3",
+    "vitest": "^3.2.6"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^8.0.0"
+  }
+}