Remove :storage-inmemory module, tests, and related code.

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/DisableToolsetTool.kt

@@ -1,5 +1,6 @@
 package pw.binom.agentik.toolsets
 
+import kotlinx.serialization.Serializable
 import pw.binom.litert.LiteTool
 
 /**
@@ -17,20 +18,20 @@ import pw.binom.litert.LiteTool
  */
 class DisableToolsetTool(private val registry: ToolsetRegistry) {
 
-    val tool: LiteTool = syncLiteTool(
-        describeJson = DESCRIBE,
-        handler = ::invoke,
-    )
+    val tool: LiteTool = liteToolSuspend<DisableArgs>(
+        name = NAME,
+        description = "Deactivate a toolset by name. Its tools become unavailable.",
+    ) { args ->
+        invoke(args)
+    }
 
-    internal suspend fun invoke(args: String): String {
-        val name = parseName(args) ?: return "missing required argument 'name'"
+    internal suspend fun invoke(args: DisableArgs): String {
+        val name = args.name
         val toolset = registry.findByName(name)
         if (toolset != null) {
-            // Единообразный ответ независимо от текущего состояния.
             registry.deactivate(name)
             return "Toolset '$name' deactivated."
         }
-        // Неизвестный — перечисляем активные (что можно деактивировать)
         val actives = registry.activeNames()
         return if (actives.isEmpty()) {
             "Toolset '$name' not found. No toolsets to deactivate."
@@ -39,11 +40,10 @@ class DisableToolsetTool(private val registry: ToolsetRegistry) {
         }
     }
 
+    @Serializable
+    internal data class DisableArgs(val name: String)
+
     companion object {
         const val NAME: String = "disable_toolset"
-
-        internal val DESCRIBE: String = """
-            {"name":"$NAME","description":"Deactivate a toolset by name. Its tools become unavailable.","parameters":{"type":"object","properties":{"name":{"type":"string","description":"Name of the toolset to deactivate."}},"required":["name"]}}
-        """.trimIndent()
     }
 }

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/EnableToolsetTool.kt

@@ -1,8 +1,6 @@
 package pw.binom.agentik.toolsets
 
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.Serializable
 import pw.binom.litert.LiteTool
 
 /**
@@ -20,20 +18,21 @@ import pw.binom.litert.LiteTool
  */
 class EnableToolsetTool(private val registry: ToolsetRegistry) {
 
-    val tool: LiteTool = syncLiteTool(
-        describeJson = DESCRIBE,
-        handler = ::invoke,
-    )
+    val tool: LiteTool = liteToolSuspend<EnableArgs>(
+        name = NAME,
+        description = "Activate a toolset by name to access its tools.",
+    ) { args ->
+        invoke(args)
+    }
 
-    internal suspend fun invoke(args: String): String {
-        val name = parseName(args) ?: return "missing required argument 'name'"
+    internal suspend fun invoke(args: EnableArgs): String {
+        val name = args.name
         val toolset = registry.findByName(name)
         if (toolset != null) {
             val wasActive = registry.isActive(name)
             registry.activate(name)
             return if (wasActive) "Toolset '$name' already active." else "Toolset '$name' activated."
         }
-        // Неизвестный — перечисляем доступные к активации (inactives)
         val inactives = registry.inactiveNames()
         return if (inactives.isEmpty()) {
             "Toolset '$name' not found. No toolsets available for activation."
@@ -42,23 +41,10 @@ class EnableToolsetTool(private val registry: ToolsetRegistry) {
         }
     }
 
+    @Serializable
+    internal data class EnableArgs(val name: String)
+
     companion object {
         const val NAME: String = "enable_toolset"
-
-        /**
-         * JSON-дескриптор для модели. Минимально: имя, описание, параметры.
-         * Соответствует litert-kmp формату LiteTool.describe().
-         */
-        internal val DESCRIBE: String = """
-            {"name":"$NAME","description":"Activate a toolset by name to access its tools.","parameters":{"type":"object","properties":{"name":{"type":"string","description":"Name of the toolset to activate."}},"required":["name"]}}
-        """.trimIndent()
     }
 }
-
-/**
- * Парсит обязательный аргумент `name` из JSON-строки аргументов тула.
- * Возвращает null если отсутствует или не строка.
- */
-internal fun parseName(argsJson: String): String? = runCatching {
-    Json.parseToJsonElement(argsJson).jsonObject["name"]?.jsonPrimitive?.content
-}.getOrNull()

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/NamedTool.kt

@@ -1,15 +0,0 @@
-package pw.binom.agentik.toolsets
-
-import pw.binom.litert.LiteTool
-
-/**
- * (имя-как-видит-модель) → [LiteTool].
- *
- * Имя используется как ключ для матчинга `LiteToolCall.name` (приходящего от LLM)
- * с конкретной реализацией тула. Для MCP-адаптеров имя имеет формат `server__tool`,
- * чтобы избежать коллизий между разными MCP-серверами.
- *
- * Перенесён из `:standalone/agent/NamedTool.kt` — это generic data-класс,
- * должен жить рядом с другими тулами в `:agent-toolsets`.
- */
-data class NamedTool(val name: String, val tool: LiteTool)

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/SyncLiteTool.kt

@@ -2,9 +2,10 @@ package pw.binom.agentik.toolsets
 
 import kotlinx.coroutines.runBlocking
 import pw.binom.litert.LiteTool
+import pw.binom.litert.tools.kotlinx.serialization.liteTool
 
 /**
- * Адаптер из suspend-handler'а в синхронный [LiteTool].
+ * Обёртка из suspend-handler'а в синхронный [LiteTool].
  *
  * `LiteTool.invoke` по контракту litert-kmp — синхронный (не suspend). Это
  * упрощает движок (LiteRT-LM вызывает тул из блокирующего потока), но создаёт
@@ -13,10 +14,17 @@ import pw.binom.litert.LiteTool
  * `runBlocking` выполняет suspend-лямбду в том же потоке, что и сам
  * LiteLlm-вызов; LiteRT-LM не делает предположений о многопоточности тулов.
  *
+ * Сейчас НЕ используется напрямую — современный путь это [liteToolSuspend],
+ * который генерит JSON-схему из `@Serializable Args` через
+ * `litert-tools-kotlinx-serialization`. Класс оставлен как escape hatch для
+ * тулов, чьи описания не получается выразить через `Args` (например, динамические
+ * JSON Schema, приходящие со стороны).
+ *
  * Используется [EnableToolsetTool] и [DisableToolsetTool] — им нужно дёргать
  * `ToolsetRegistry` (suspend, из-за Mutex) из синхронного LiteTool-контекста.
  */
 internal class SyncLiteTool(
+    override val name: String,
     private val describeJson: String,
     private val handler: suspend (String) -> String,
 ) : LiteTool {
@@ -25,9 +33,35 @@ internal class SyncLiteTool(
 }
 
 /**
- * Утилита для создания [LiteTool] из JSON-дескриптора и suspend-обработчика.
- * Сейчас эквивалентно `SyncLiteTool(json, handler).invoke(json)` — оставлено
- * как API-точка чтобы внешний код не зависел от internal-имени класса.
+ * Строит [LiteTool] из suspend-handler'а и `@Serializable Args`.
+ * JSON-схема генерится автоматически из `Args.descriptor`,
+ * а сырая строка аргументов десериализуется в типизированный [Args].
+ *
+ * Использование:
+ * ```
+ * val t: LiteTool = liteToolSuspend<MyArgs>(name = "foo", description = "...") { args ->
+ *     suspendBlock(args) // MyArgs уже распарсен
+ * }
+ * ```
+ *
+ * Реализация: под капотом используется [pw.binom.litert.tools.kotlinx.serialization.liteTool] —
+ * его sync-handler запускает наш suspend-handler в [runBlocking].
  */
-internal fun syncLiteTool(describeJson: String, handler: suspend (String) -> String): LiteTool =
-    SyncLiteTool(describeJson, handler)
+inline fun <reified Args> liteToolSuspend(
+    name: String,
+    description: String = "",
+    noinline handler: suspend (Args) -> String,
+): LiteTool = liteTool<Args>(
+    name = name,
+    description = description,
+) { args ->
+    runBlocking { handler(args) }
+}
+
+@PublishedApi
+internal val invocationJson: kotlinx.serialization.json.Json = kotlinx.serialization.json.Json {
+    ignoreUnknownKeys = true
+    isLenient = false
+    coerceInputValues = true
+    explicitNulls = false
+}

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/ToolsetComponent.kt

@@ -0,0 +1,103 @@
+package pw.binom.agentik.toolsets
+
+import pw.binom.agentik.agent.Component
+import pw.binom.agentik.agent.MutableAgent
+import pw.binom.agentik.agent.SystemPromptProvider
+import pw.binom.agentik.agent.ToolProvider
+import pw.binom.litert.LiteTool
+
+/**
+ * Подключает механику toolsets к агенту:
+ *  - [ToolsetRegistry] (per-component instance — раньше жил в ChatAgent).
+ *  - Тулы [EnableToolsetTool] и [DisableToolsetTool] всегда доступны — модель
+ *    ими переключает состояние.
+ *  - Тулы активных тулсетов — динамически: после `enable_toolset(name=X)`
+ *    X.tools становятся видны через [ToolProvider.getTools] уже на
+ *    следующем turn'е.
+ *  - Секция системного промпта — список активных/неактивных тулсетов,
+ *    чтобы модель знала что включено.
+ *
+ * Один [ToolsetComponent] на агента. Шарится между беседами через общий
+ * [MutableAgent] (все conversations читают один [ToolsetRegistry]).
+ *
+ * `install(agent)` идемпотентно. `uninstall(agent)` снимает оба провайдера
+ * по типу (см. [ToolsetToolProvider], [ToolsetSystemProvider]).
+ */
+class ToolsetComponent(
+    private val contributions: List<ToolsetContribution>,
+) : Component {
+
+    /**
+     * Реестр тулсетов, владеет [ToolsetComponent]. `private` — наружу не светится,
+     * чтобы никто не дёргал его мимо `enable_toolset`/`disable_toolset` тулов.
+     */
+    private val registry: ToolsetRegistry = ToolsetRegistry(contributions)
+
+    private var provider: ToolsetToolProvider? = null
+
+    override fun install(agent: MutableAgent) {
+        val p = ToolsetToolProvider(registry, contributions)
+        agent.toolProviders.add(p)
+        provider = p
+        agent.systemProviders.add(ToolsetSystemProvider(registry))
+    }
+
+    override fun uninstall(agent: MutableAgent) {
+        provider?.let { agent.toolProviders.remove(it) }
+        agent.systemProviders.removeAll { it is ToolsetSystemProvider }
+    }
+}
+
+/**
+ * Возвращает тулсет-тулы в зависимости от текущего состояния реестра:
+ *  - `enable_toolset` / `disable_toolset` — всегда.
+ *  - Тулы активных тулсетов — те, что перечислены в [ToolsetRegistry.activeNames].
+ *
+ * Snapshot собирается на каждом вызове [getTools] — диспетчер видит свежее
+ * состояние после `enable_toolset` уже на следующем turn'е.
+ */
+class ToolsetToolProvider(
+    private val registry: ToolsetRegistry,
+    private val contributions: List<ToolsetContribution>,
+) : ToolProvider {
+
+    override fun getTools(conversationId: String): List<LiteTool> = buildList {
+        add(EnableToolsetTool(registry).tool)
+        add(DisableToolsetTool(registry).tool)
+        // Активные тулсеты — добавляем их тулы в общий пул. Это синхронная
+        // версия (lock-free snapshot), потому что `getTools` вызывается
+        // синхронно из `collectTools()`; `active` сам по себе Concurrent-Set
+        // через Mutex в реестре (все мутации — через activate/deactivate).
+        val active = runBlockingSnapshot()
+        contributions.filter { it.name in active }.forEach { c ->
+            c.tools.forEach { add(it.tool) }
+        }
+    }
+
+    /**
+     * Снимает снимок активных имён без suspend-блокировки.
+     * ToolsetRegistry.activeNames() — suspend, но его можно обойти если
+     * вычислить через прямой snapshot — для простоты используем runBlocking.
+     * Это всё равно вызывается на каждый turn, но мьютекс короткий.
+     */
+    private fun runBlockingSnapshot(): Set<String> = kotlinx.coroutines.runBlocking {
+        registry.activeNames().toSet()
+    }
+}
+
+/**
+ * Секция системного промпта с описанием доступных тулсетов:
+ *  - `*active*` — что уже подключено.
+ *  - `*inactive*` — что доступно через `enable_toolset`.
+ */
+class ToolsetSystemProvider(
+    private val registry: ToolsetRegistry,
+) : SystemPromptProvider {
+    override fun getSection(conversationId: String): String {
+        val activeNames = kotlinx.coroutines.runBlocking { registry.activeNames() }.toSet()
+        val all = registry.all()
+        val active = all.filter { it.name in activeNames }
+        val inactive = all.filter { it.name !in activeNames }
+        return SystemPromptToolsetSection.render(active = active, inactive = inactive) ?: ""
+    }
+}

agent-toolsets/src/commonTest/kotlin/pw/binom/agentik/toolsets/DisableToolsetToolTest.kt

@@ -8,6 +8,7 @@ import kotlin.test.assertEquals
 class DisableToolsetToolTest {
 
     private fun tool(name: String): LiteTool = object : LiteTool {
+        override val name: String = name
         override fun describe() = """{"name":"$name","description":"x","parameters":{"type":"object","properties":{}}}"""
         override fun invoke(arguments: String) = "ok"
     }
@@ -32,7 +33,7 @@ class DisableToolsetToolTest {
             ToolsetContribution("media", "media tools", emptyList()),
         ))
         reg.activate("media")
-        val r = disable.invoke("""{"name":"media"}""")
+        val r = disable.invoke(DisableToolsetTool.DisableArgs(name = "media"))
         assertEquals("Toolset 'media' deactivated.", r)
         assertEquals(false, reg.isActive("media"))
     }
@@ -42,8 +43,7 @@ class DisableToolsetToolTest {
         val (disable, _) = harness(listOf(
             ToolsetContribution("media", "media tools", emptyList()),
         ))
-        // тулсет изначально неактивен — должно быть тот же ответ (uniform)
-        val r = disable.invoke("""{"name":"media"}""")
+        val r = disable.invoke(DisableToolsetTool.DisableArgs(name = "media"))
         assertEquals("Toolset 'media' deactivated.", r)
     }
 
@@ -55,7 +55,7 @@ class DisableToolsetToolTest {
         ))
         reg.activate("a")
         reg.activate("b")
-        val r = disable.invoke("""{"name":"unknown"}""")
+        val r = disable.invoke(DisableToolsetTool.DisableArgs(name = "unknown"))
         assertEquals("Toolset 'unknown' not found. Available for deactivation: a, b.", r)
     }
 
@@ -64,14 +64,7 @@ class DisableToolsetToolTest {
         val (disable, _) = harness(listOf(
             ToolsetContribution("a", "x", emptyList()),
         ))
-        val r = disable.invoke("""{"name":"unknown"}""")
+        val r = disable.invoke(DisableToolsetTool.DisableArgs(name = "unknown"))
         assertEquals("Toolset 'unknown' not found. No toolsets to deactivate.", r)
     }
-
-    @Test
-    fun `missing name argument returns error message`() = runTest {
-        val (disable, _) = harness(emptyList())
-        val r = disable.invoke("""{}""")
-        assertEquals("missing required argument 'name'", r)
-    }
 }

agent-toolsets/src/commonTest/kotlin/pw/binom/agentik/toolsets/EnableToolsetToolTest.kt

@@ -8,6 +8,7 @@ import kotlin.test.assertEquals
 class EnableToolsetToolTest {
 
     private fun tool(name: String): LiteTool = object : LiteTool {
+        override val name: String = name
         override fun describe() = """{"name":"$name","description":"x","parameters":{"type":"object","properties":{}}}"""
         override fun invoke(arguments: String) = "ok"
     }
@@ -31,7 +32,7 @@ class EnableToolsetToolTest {
         val (enable, reg) = harness(listOf(
             ToolsetContribution("media", "media tools", listOf(ToolsetContribution.ToolEntry("resize_image", tool("resize_image")))),
         ))
-        val r = enable.invoke("""{"name":"media"}""")
+        val r = enable.invoke(EnableToolsetTool.EnableArgs(name = "media"))
         assertEquals("Toolset 'media' activated.", r)
         assertEquals(true, reg.isActive("media"))
     }
@@ -42,7 +43,7 @@ class EnableToolsetToolTest {
             ToolsetContribution("media", "media tools", emptyList()),
         ))
         reg.activate("media")
-        val r = enable.invoke("""{"name":"media"}""")
+        val r = enable.invoke(EnableToolsetTool.EnableArgs(name = "media"))
         assertEquals("Toolset 'media' already active.", r)
     }
 
@@ -53,7 +54,7 @@ class EnableToolsetToolTest {
             ToolsetContribution("b", "y", emptyList()),
             ToolsetContribution("c", "z", emptyList()),
         ))
-        val r = enable.invoke("""{"name":"unknown"}""")
+        val r = enable.invoke(EnableToolsetTool.EnableArgs(name = "unknown"))
         assertEquals("Toolset 'unknown' not found. Available: a, b, c.", r)
     }
 
@@ -63,14 +64,7 @@ class EnableToolsetToolTest {
             ToolsetContribution("a", "x", emptyList()),
         ))
         reg.activate("a")
-        val r = enable.invoke("""{"name":"unknown"}""")
+        val r = enable.invoke(EnableToolsetTool.EnableArgs(name = "unknown"))
         assertEquals("Toolset 'unknown' not found. No toolsets available for activation.", r)
     }
-
-    @Test
-    fun `missing name argument returns error message`() = runTest {
-        val (enable, _) = harness(emptyList())
-        val r = enable.invoke("""{}""")
-        assertEquals("missing required argument 'name'", r)
-    }
 }

agent-toolsets/src/commonTest/kotlin/pw/binom/agentik/toolsets/ToolsetDispatchPolicyTest.kt

@@ -11,6 +11,7 @@ import kotlin.test.assertTrue
 class ToolsetDispatchPolicyTest {
 
     private fun tool(name: String, response: String = "ok:$name"): LiteTool = object : LiteTool {
+        override val name: String = name
         override fun describe() = """{"name":"$name","description":"test tool","parameters":{"type":"object","properties":{}}}"""
         override fun invoke(arguments: String) = response
     }

agent-toolsets/src/commonTest/kotlin/pw/binom/agentik/toolsets/ToolsetRegistryTest.kt

@@ -12,6 +12,7 @@ import kotlin.test.assertTrue
 class ToolsetRegistryTest {
 
     private fun tool(name: String): LiteTool = object : LiteTool {
+        override val name: String = name
         override fun describe() = """{"name":"$name","description":"test tool","parameters":{"type":"object","properties":{}}}"""
         override fun invoke(arguments: String) = "ok:$name"
     }