@independo/capacitor-inderun 0.2.0-dev.0

package/android/src/main/kotlin/app/independo/inderun/capacitor/IndeRunCapacitorPlugin.kt

@@ -0,0 +1,111 @@
+package app.independo.inderun.capacitor
+
+import app.independo.inderun.core.IndeRunException
+import app.independo.inderun.core.ProviderRegistry
+import app.independo.inderun.core.toIndeRunException
+import app.independo.inderun.providers.mlkit.AndroidProviderRegistryFactory
+import app.independo.inderun.providers.openai.DEFAULT_OPENAI_RESPONSES_ENDPOINT
+import app.independo.inderun.providers.openai.OpenAIAuthMode
+import app.independo.inderun.providers.openai.OpenAIProvider
+import app.independo.inderun.providers.openai.OpenAIProviderOptions
+import app.independo.inderun.sdk.IndeRun
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+@CapacitorPlugin(name = "IndeRunCapacitor")
+class IndeRunCapacitorPlugin : Plugin() {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    private var configuredRegistry: ProviderRegistry? = null
+
+    @PluginMethod
+    fun configure(call: PluginCall) {
+        try {
+            val options = IndeRunSerializer.parseConfigureOptions(call.data)
+            configuredRegistry = createRegistry(options.openAI)
+            call.resolve()
+        } catch (error: IndeRunException) {
+            val contractError = error.toContractError()
+            call.reject(
+                contractError.message,
+                contractError.errorClass.rawValue,
+                null,
+                runCatching { IndeRunSerializer.encodeError(contractError) }.getOrNull()
+            )
+        } catch (error: Throwable) {
+            val normalized = toIndeRunException(error)
+            val contractError = normalized.toContractError()
+            call.reject(
+                contractError.message,
+                contractError.errorClass.rawValue,
+                null,
+                runCatching { IndeRunSerializer.encodeError(contractError) }.getOrNull()
+            )
+        }
+    }
+
+    @PluginMethod
+    fun run(call: PluginCall) {
+        val requestJson = call.data
+
+        scope.launch {
+            try {
+                val registry = configuredRegistry
+                    ?: throw toIndeRunException(IllegalStateException("Capacitor IndeRun has not been configured. Configure providers before calling run(request)."))
+                val request = IndeRunSerializer.parseTaskRequest(requestJson)
+                // IndeRun is stateless; new per call is intentional — registry is cached after configure().
+                val result = IndeRun.initialize(context.applicationContext, registry).run(request)
+                call.resolve(IndeRunSerializer.encodeTaskResult(result))
+            } catch (error: IndeRunException) {
+                val contractError = error.toContractError()
+                call.reject(
+                    contractError.message,
+                    contractError.errorClass.rawValue,
+                    null,
+                    runCatching { IndeRunSerializer.encodeError(contractError) }.getOrNull()
+                )
+            } catch (error: Throwable) {
+                val normalized = toIndeRunException(error)
+                val contractError = normalized.toContractError()
+                call.reject(
+                    contractError.message,
+                    contractError.errorClass.rawValue,
+                    null,
+                    runCatching { IndeRunSerializer.encodeError(contractError) }.getOrNull()
+                )
+            }
+        }
+    }
+
+    override fun handleOnDestroy() {
+        scope.cancel()
+        super.handleOnDestroy()
+    }
+
+    private fun createRegistry(openAI: OpenAIProviderBootstrapOptions?): ProviderRegistry {
+        val registry = AndroidProviderRegistryFactory.makeDefaultRegistry(context.applicationContext)
+
+        if (openAI != null) {
+            registry.register(
+                OpenAIProvider(
+                    OpenAIProviderOptions(
+                        id = "openai",
+                        model = openAI.model,
+                        endpointUrl = openAI.endpointUrl ?: DEFAULT_OPENAI_RESPONSES_ENDPOINT,
+                        auth = if (openAI.auth == "none") OpenAIAuthMode.none else OpenAIAuthMode.authContextRef,
+                        authContextRef = openAI.authContextRef,
+                        timeoutMs = openAI.timeoutMs
+                    )
+                )
+            )
+        }
+
+        return registry
+    }
+}

package/android/src/main/kotlin/app/independo/inderun/capacitor/IndeRunSerializer.kt

@@ -0,0 +1,263 @@
+package app.independo.inderun.capacitor
+
+import app.independo.inderun.contracts.Cloud
+import app.independo.inderun.contracts.FinishReason
+import app.independo.inderun.contracts.Generation
+import app.independo.inderun.contracts.IndeRunError
+import app.independo.inderun.contracts.IndeRunErrorClass
+import app.independo.inderun.contracts.Message
+import app.independo.inderun.contracts.MessageRole
+import app.independo.inderun.contracts.OptimizeFor
+import app.independo.inderun.contracts.OutputType
+import app.independo.inderun.contracts.PrivacyEnum
+import app.independo.inderun.contracts.SchemaVersion
+import app.independo.inderun.contracts.TaskKind
+import app.independo.inderun.contracts.TaskRequest
+import app.independo.inderun.contracts.TaskRequestConstraints
+import app.independo.inderun.contracts.TaskRequestPreferences
+import app.independo.inderun.contracts.TaskRequestTask
+import app.independo.inderun.contracts.TaskRequestTelemetry
+import app.independo.inderun.contracts.TaskResult
+import app.independo.inderun.contracts.TaskResultTelemetry
+import app.independo.inderun.contracts.TelemetryLevel
+import app.independo.inderun.contracts.Usage
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class OpenAIProviderBootstrapOptions(
+    val model: String,
+    val endpointUrl: String? = null,
+    val auth: String? = null,
+    val authContextRef: String? = null,
+    val timeoutMs: Long? = null
+)
+
+data class RunOptions(
+    val openAI: OpenAIProviderBootstrapOptions? = null
+)
+
+object IndeRunSerializer {
+    fun parseConfigureOptions(json: JSONObject): RunOptions {
+        return RunOptions(
+            openAI = json.optJSONObject("openAI")?.let(::parseOpenAIOptions)
+        )
+    }
+
+    fun parseTaskRequest(json: JSONObject): TaskRequest {
+        return TaskRequest(
+            authContextRef = json.optStringOrNull("authContextRef"),
+            constraints = json.optJSONObject("constraints")?.let(::parseConstraints),
+            generation = json.optJSONObject("generation")?.let(::parseGeneration),
+            messages = json.optJSONArray("messages")?.let(::parseMessages),
+            preferences = json.optJSONObject("preferences")?.let(::parsePreferences),
+            prompt = json.optStringOrNull("prompt"),
+            requestId = json.optStringOrNull("requestId"),
+            schemaVersion = parseSchemaVersion(json.getString("schemaVersion")),
+            task = parseTask(json.getJSONObject("task")),
+            telemetry = json.optJSONObject("telemetry")?.let(::parseTelemetry)
+        )
+    }
+
+    fun encodeTaskResult(result: TaskResult): JSObject {
+        return JSObject().apply {
+            put("schemaVersion", result.schemaVersion.rawValue)
+            put("runId", result.runId)
+            put("finishReason", result.finishReason.rawValue)
+            put(
+                "output",
+                JSObject()
+                    .put("type", result.output.type.rawValue)
+                    .put("text", result.output.text)
+            )
+            put(
+                "telemetry",
+                JSObject()
+                    .put("providerUsed", result.telemetry.providerUsed)
+                    .put("totalMs", result.telemetry.totalMs)
+                    .apply {
+                        result.telemetry.errorClass?.let { put("errorClass", it.rawValue) }
+                    }
+            )
+            result.usage?.let { usage ->
+                put(
+                    "usage",
+                    JSObject().apply {
+                        usage.inputTokens?.let { put("inputTokens", it) }
+                        usage.outputTokens?.let { put("outputTokens", it) }
+                        usage.totalTokens?.let { put("totalTokens", it) }
+                    }
+                )
+            }
+        }
+    }
+
+    fun encodeError(error: IndeRunError): JSObject {
+        return JSObject().apply {
+            put("schemaVersion", error.schemaVersion.rawValue)
+            put("errorClass", error.errorClass.rawValue)
+            put("message", error.message)
+            error.providerId?.let { put("providerId", it) }
+            error.retryable?.let { put("retryable", it) }
+            error.retryAfterMs?.let { put("retryAfterMs", it) }
+            error.runId?.let { put("runId", it) }
+            error.details?.let { put("details", JSONObject(it)) }
+        }
+    }
+
+    private fun parseOpenAIOptions(json: JSONObject): OpenAIProviderBootstrapOptions {
+        return OpenAIProviderBootstrapOptions(
+            model = json.getString("model"),
+            endpointUrl = json.optStringOrNull("endpointUrl"),
+            auth = json.optStringOrNull("auth"),
+            authContextRef = json.optStringOrNull("authContextRef"),
+            timeoutMs = json.optLongOrNull("timeoutMs")
+        )
+    }
+
+    private fun parseConstraints(json: JSONObject): TaskRequestConstraints {
+        return TaskRequestConstraints(
+            cloud = json.optStringOrNull("cloud")?.let(::parseCloud),
+            privacy = json.optStringOrNull("privacy")?.let(::parsePrivacy),
+            timeoutMs = json.optLongOrNull("timeoutMs")
+        )
+    }
+
+    private fun parseGeneration(json: JSONObject): Generation {
+        return Generation(
+            maxOutputTokens = json.optLongOrNull("maxOutputTokens"),
+            seed = json.optLongOrNull("seed"),
+            stop = json.optJSONArray("stop")?.toStringList(),
+            temperature = json.optDoubleOrNull("temperature"),
+            topP = json.optDoubleOrNull("topP")
+        )
+    }
+
+    private fun parseMessages(json: JSONArray): List<Message> {
+        return buildList {
+            for (index in 0 until json.length()) {
+                val message = json.getJSONObject(index)
+                add(
+                    Message(
+                        role = parseRole(message.getString("role")),
+                        content = message.getString("content")
+                    )
+                )
+            }
+        }
+    }
+
+    private fun parsePreferences(json: JSONObject): TaskRequestPreferences {
+        return TaskRequestPreferences(
+            optimizeFor = json.optStringOrNull("optimizeFor")?.let(::parseOptimizeFor)
+        )
+    }
+
+    private fun parseTask(json: JSONObject): TaskRequestTask {
+        return TaskRequestTask(kind = parseTaskKind(json.getString("kind")))
+    }
+
+    private fun parseTelemetry(json: JSONObject): TaskRequestTelemetry {
+        return TaskRequestTelemetry(
+            consent = json.optBooleanOrNull("consent"),
+            level = json.optStringOrNull("level")?.let(::parseTelemetryLevel),
+            tags = json.optJSONObject("tags")?.toStringMap()
+        )
+    }
+
+    private fun parseSchemaVersion(value: String): SchemaVersion {
+        return when (value) {
+            "1.0" -> SchemaVersion.V1_0
+            else -> throw IllegalArgumentException("Unsupported schemaVersion '$value'.")
+        }
+    }
+
+    private fun parseCloud(value: String): Cloud {
+        return when (value) {
+            "allowed" -> Cloud.Allowed
+            "forbidden" -> Cloud.Forbidden
+            "required" -> Cloud.Required
+            else -> throw IllegalArgumentException("Unsupported cloud constraint '$value'.")
+        }
+    }
+
+    private fun parsePrivacy(value: String): PrivacyEnum {
+        return when (value) {
+            "local_required" -> PrivacyEnum.LocalRequired
+            "local_preferred" -> PrivacyEnum.LocalPreferred
+            "cloud_allowed" -> PrivacyEnum.CloudAllowed
+            "cloud_required" -> PrivacyEnum.CloudRequired
+            else -> throw IllegalArgumentException("Unsupported privacy constraint '$value'.")
+        }
+    }
+
+    private fun parseRole(value: String): MessageRole {
+        return when (value) {
+            "assistant" -> MessageRole.ASSISTANT
+            "system" -> MessageRole.SYSTEM
+            "user" -> MessageRole.USER
+            else -> throw IllegalArgumentException("Unsupported message role '$value'.")
+        }
+    }
+
+    private fun parseOptimizeFor(value: String): OptimizeFor {
+        return when (value) {
+            "balanced" -> OptimizeFor.Balanced
+            "cost" -> OptimizeFor.Cost
+            "latency" -> OptimizeFor.Latency
+            "privacy" -> OptimizeFor.Privacy
+            else -> throw IllegalArgumentException("Unsupported optimizeFor '$value'.")
+        }
+    }
+
+    private fun parseTaskKind(value: String): TaskKind {
+        return when (value) {
+            "text_to_text" -> TaskKind.TEXT_TO_TEXT
+            else -> throw IllegalArgumentException("Unsupported task kind '$value'.")
+        }
+    }
+
+    private fun parseTelemetryLevel(value: String): TelemetryLevel {
+        return when (value) {
+            "debug" -> TelemetryLevel.DEBUG
+            "minimal" -> TelemetryLevel.MINIMAL
+            "off" -> TelemetryLevel.OFF
+            else -> throw IllegalArgumentException("Unsupported telemetry level '$value'.")
+        }
+    }
+}
+
+private fun JSONObject.optStringOrNull(key: String): String? {
+    return if (has(key) && !isNull(key)) getString(key) else null
+}
+
+private fun JSONObject.optLongOrNull(key: String): Long? {
+    return if (has(key) && !isNull(key)) getLong(key) else null
+}
+
+private fun JSONObject.optDoubleOrNull(key: String): Double? {
+    return if (has(key) && !isNull(key)) getDouble(key) else null
+}
+
+private fun JSONObject.optBooleanOrNull(key: String): Boolean? {
+    return if (has(key) && !isNull(key)) getBoolean(key) else null
+}
+
+private fun JSONObject.toStringMap(): Map<String, String> {
+    val result = linkedMapOf<String, String>()
+    val keys = keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        result[key] = getString(key)
+    }
+    return result
+}
+
+private fun JSONArray.toStringList(): List<String> {
+    return buildList {
+        for (index in 0 until length()) {
+            add(getString(index))
+        }
+    }
+}

package/android/src/test/kotlin/app/independo/inderun/capacitor/IndeRunSerializerTest.kt

@@ -0,0 +1,180 @@
+package app.independo.inderun.capacitor
+
+import app.independo.inderun.contracts.FinishReason
+import app.independo.inderun.contracts.IndeRunError
+import app.independo.inderun.contracts.IndeRunErrorClass
+import app.independo.inderun.contracts.Output
+import app.independo.inderun.contracts.SchemaVersion
+import app.independo.inderun.contracts.TaskRequest
+import app.independo.inderun.contracts.TaskRequestTask
+import app.independo.inderun.contracts.TaskResult
+import app.independo.inderun.contracts.TaskResultTelemetry
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class IndeRunSerializerTest {
+    @Test
+    fun `parseRunOptions decodes canonical request fields`() {
+        val request = IndeRunSerializer.parseTaskRequest(
+            JSONObject(
+                """
+                {
+                  "schemaVersion": "1.0",
+                  "task": { "kind": "text_to_text" },
+                  "prompt": "Hello",
+                  "constraints": { "privacy": "cloud_required" }
+                }
+                """.trimIndent()
+            )
+        )
+        val options = IndeRunSerializer.parseConfigureOptions(
+            JSONObject(
+                """
+                {
+                  "openAI": {
+                    "model": "gpt-5.2",
+                    "endpointUrl": "/api/inderun/openai-responses",
+                    "auth": "none"
+                  }
+                }
+                """.trimIndent()
+            )
+        )
+
+        assertEquals("Hello", request.prompt)
+        assertEquals("gpt-5.2", options.openAI?.model)
+        assertEquals("/api/inderun/openai-responses", options.openAI?.endpointUrl)
+    }
+
+    @Test
+    fun `encodeTaskResult preserves canonical task result shape`() {
+        val encoded = IndeRunSerializer.encodeTaskResult(
+            TaskResult(
+                finishReason = FinishReason.STOP,
+                output = Output(text = "Hi"),
+                runId = "run_123",
+                schemaVersion = SchemaVersion.V1_0,
+                telemetry = TaskResultTelemetry(providerUsed = "openai", totalMs = 12.0)
+            )
+        )
+
+        assertEquals("1.0", encoded.getString("schemaVersion"))
+        assertEquals("stop", encoded.getString("finishReason"))
+        assertEquals("Hi", encoded.getJSONObject("output").getString("text"))
+        assertEquals("openai", encoded.getJSONObject("telemetry").getString("providerUsed"))
+    }
+
+    // --- Unknown enum values throw ---
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown schemaVersion`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"9.9","task":{"kind":"text_to_text"},"prompt":"Hello"}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown task kind`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"image_to_text"},"prompt":"Hello"}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown cloud constraint`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi","constraints":{"cloud":"maybe"}}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown privacy constraint`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi","constraints":{"privacy":"some_value"}}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown message role`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi","messages":[{"role":"moderator","content":"Hi"}]}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown optimizeFor`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi","preferences":{"optimizeFor":"turbo"}}""")
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `parseTaskRequest throws on unknown telemetry level`() {
+        IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi","telemetry":{"level":"verbose"}}""")
+        )
+    }
+
+    // --- Absent optional fields ---
+
+    @Test
+    fun `parseTaskRequest accepts minimal request with all optionals absent`() {
+        val request = IndeRunSerializer.parseTaskRequest(
+            JSONObject("""{"schemaVersion":"1.0","task":{"kind":"text_to_text"},"prompt":"Hi"}""")
+        )
+        assertNull(request.authContextRef)
+        assertNull(request.constraints)
+        assertNull(request.generation)
+        assertNull(request.messages)
+        assertNull(request.preferences)
+        assertNull(request.requestId)
+        assertNull(request.telemetry)
+    }
+
+    @Test
+    fun `parseConfigureOptions accepts empty object`() {
+        val options = IndeRunSerializer.parseConfigureOptions(JSONObject("{}"))
+        assertNull(options.openAI)
+    }
+
+    // --- encodeError ---
+
+    @Test
+    fun `encodeError produces correct shape with required fields only`() {
+        val encoded = IndeRunSerializer.encodeError(
+            IndeRunError(
+                errorClass = IndeRunErrorClass.Unavailable,
+                message = "Not configured."
+            )
+        )
+        assertEquals("1.0", encoded.getString("schemaVersion"))
+        assertEquals("Unavailable", encoded.getString("errorClass"))
+        assertEquals("Not configured.", encoded.getString("message"))
+        assertFalse(encoded.has("providerId"))
+        assertFalse(encoded.has("retryable"))
+        assertFalse(encoded.has("retryAfterMs"))
+        assertFalse(encoded.has("runId"))
+    }
+
+    @Test
+    fun `encodeError includes all optional fields when set`() {
+        val encoded = IndeRunSerializer.encodeError(
+            IndeRunError(
+                errorClass = IndeRunErrorClass.RateLimited,
+                message = "Rate limit exceeded.",
+                providerId = "openai",
+                retryable = true,
+                retryAfterMs = 2000L,
+                runId = "run_abc"
+            )
+        )
+        assertEquals("RateLimited", encoded.getString("errorClass"))
+        assertEquals("openai", encoded.getString("providerId"))
+        assertEquals(true, encoded.getBoolean("retryable"))
+        assertEquals(2000L, encoded.getLong("retryAfterMs"))
+        assertEquals("run_abc", encoded.getString("runId"))
+    }
+}

package/dist/definitions.d.ts

@@ -0,0 +1,17 @@
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+export interface OpenAIProviderBootstrapOptions {
+    model: string;
+    endpointUrl?: string;
+    auth?: "authContextRef" | "none";
+    authContextRef?: string;
+    timeoutMs?: number;
+}
+export interface ConfigureOptions {
+    openAI?: OpenAIProviderBootstrapOptions;
+    allowDirectOpenAIEndpoint?: boolean;
+}
+export interface IndeRunCapacitorPlugin {
+    configure(options?: ConfigureOptions): Promise<void>;
+    run(request: TaskRequest): Promise<TaskResult>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE5E,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,8BAA8B,CAAC;IACxC,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAChD"}

package/dist/definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
+import type { ConfigureOptions, IndeRunCapacitorPlugin as IndeRunCapacitorPluginContract, OpenAIProviderBootstrapOptions } from "./definitions.js";
+export declare const IndeRunCapacitor: IndeRunCapacitorPluginContract;
+export interface IndeRunCapacitorInstance {
+    run(request: TaskRequest): Promise<TaskResult>;
+}
+export declare function createIndeRunCapacitor(options?: ConfigureOptions): IndeRunCapacitorInstance;
+export type { ConfigureOptions, IndeRunCapacitorPluginContract as IndeRunCapacitorPlugin, OpenAIProviderBootstrapOptions, TaskRequest, TaskResult };
+export type * from "@independo/inderun-contracts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,IAAI,8BAA8B,EACxD,8BAA8B,EAC/B,MAAM,kBAAkB,CAAC;AAuB1B,eAAO,MAAM,gBAAgB,EAAE,8BAgB9B,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAChD;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,wBAAwB,CAiB3F;AAED,YAAY,EACV,gBAAgB,EAChB,8BAA8B,IAAI,sBAAsB,EACxD,8BAA8B,EAC9B,WAAW,EACX,UAAU,EACX,CAAC;AAEF,mBAAmB,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,51 @@
+import { validateIndeRunError } from "@independo/inderun-contracts";
+import { registerPlugin } from "@capacitor/core";
+const IndeRunCapacitorNative = registerPlugin("IndeRunCapacitor", {
+    web: () => import("./web.js").then((module) => new module.IndeRunWeb())
+});
+function normalizePluginError(error) {
+    if (validateIndeRunError(error)) {
+        return error;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "data" in error &&
+        validateIndeRunError(error.data)) {
+        return error.data;
+    }
+    return error;
+}
+export const IndeRunCapacitor = {
+    async configure(options) {
+        try {
+            await IndeRunCapacitorNative.configure(options);
+        }
+        catch (error) {
+            throw normalizePluginError(error);
+        }
+    },
+    async run(request) {
+        try {
+            return await IndeRunCapacitorNative.run(request);
+        }
+        catch (error) {
+            throw normalizePluginError(error);
+        }
+    }
+};
+export function createIndeRunCapacitor(options) {
+    let configured = null;
+    function ensureConfigured() {
+        configured ??= IndeRunCapacitor.configure(options).catch((error) => {
+            configured = null;
+            throw error;
+        });
+        return configured;
+    }
+    return {
+        async run(request) {
+            await ensureConfigured();
+            return IndeRunCapacitor.run(request);
+        }
+    };
+}

package/dist/web.d.ts

@@ -0,0 +1,10 @@
+import type { TaskResult } from "@independo/inderun-contracts";
+import { WebPlugin } from "@capacitor/core";
+import type { ConfigureOptions, IndeRunCapacitorPlugin } from "./definitions.js";
+import type { TaskRequest } from "@independo/inderun-contracts";
+export declare class IndeRunWeb extends WebPlugin implements IndeRunCapacitorPlugin {
+    private engine;
+    configure(options?: ConfigureOptions): Promise<void>;
+    run(request: TaskRequest): Promise<TaskResult>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAGhE,qBAAa,UAAW,SAAQ,SAAU,YAAW,sBAAsB;IACzE,OAAO,CAAC,MAAM,CAAwB;IAEhC,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BpD,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;CAarD"}