multacd 2.0.0b6__tar.gz → 2.0.0b8__tar.gz

{multacd-2.0.0b6 → multacd-2.0.0b8}/.github/workflows/release.yml

@@ -101,7 +101,7 @@ jobs:
 
             ```bash
             pkg install -y python git
-            pip install "multacd==2.0.0b6"
+            pip install "multacd==2.0.0b8"
             ```
 
             Windows (PowerShell):

{multacd-2.0.0b6 → multacd-2.0.0b8}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 Format: Keep a Changelog. Versi: Semantic Versioning.
 
+## [2.0.0b8] - 2026-09-13
+
+Beta v2 kedelapan (refactor arsitektur, tanpa ubah fitur): kontrak event
+`core/agent_events` (R2), SessionState + reducer keluar widget (R3),
+AgentController + fix approve [A] lintas turn (#32, R4), widget render
+dari state (R5), research sink task-scoped (R6), splash §10 lengkap (R7).
+
+Install: `pip install "multacd==2.0.0b8"` (tanpa --pre).
+
+## [2.0.0b7] - 2026-09-12
+
+Beta v2 ketujuh (borongan): config key kosong dimaafkan (#27), limit jadi
+tawaran Lanjut/Berhenti + stagnan outcome-aware (#28), markup crash (#29),
+tavily+exa native tanpa SDK + fallback operasional (#30), key per-provider
++ /key /base (#31), splash cover + /connect + /models.
+
+Install: `pip install "multacd==2.0.0b7"` (tanpa --pre).
+
 ## [2.0.0b6] - 2026-09-12
 
 Beta v2 keenam — fix mode lupa ingatan (#26): system message di-refresh

{multacd-2.0.0b6 → multacd-2.0.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: multacd
-Version: 2.0.0b6
+Version: 2.0.0b8
 Summary: Agentic TUI for coding, research, and personal automation
 Project-URL: Homepage, https://github.com/prototypeall850-creator/multacd
 Project-URL: Issues, https://github.com/prototypeall850-creator/multacd/issues
@@ -29,10 +29,6 @@ Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.4.0; extra == 'dev'
-Provides-Extra: exa
-Requires-Dist: exa-py>=1.0.0; extra == 'exa'
-Provides-Extra: tavily
-Requires-Dist: tavily-python>=0.3.0; extra == 'tavily'
 Description-Content-Type: text/markdown
 
 # ⚡ multacd

multacd-2.0.0b8/core/agent_events.py

@@ -0,0 +1,86 @@
+"""Agent event contract — satu-satunya bahasa agent runtime → UI.
+
+Dipakai `core/agent_loop.py` (yield) dan consumer (`tui`, `tg`, tests).
+Modul ini murni dataclass: tanpa import Textual, tanpa I/O, tanpa LLM —
+tujuannya biar boundary tidak gampang bocor saat refactor (R2).
+
+Test cepat:
+    python -m core.agent_events
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AgentText:
+    delta: str
+
+
+@dataclass
+class AgentToolStart:
+    call_id: str
+    name: str
+    params: dict[str, Any]
+
+
+@dataclass
+class AgentToolDone:
+    call_id: str
+    name: str
+    success: bool
+    result: dict[str, Any] | None = None  # payload penuh (D4: expandable view)
+
+
+@dataclass
+class AgentDone:
+    text: str
+
+
+@dataclass
+class AgentUsage:
+    """Token resmi provider untuk satu panggilan LLM (0 = tak dilapor)."""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cost_usd: float = 0.0  # estimasi lokal (tabel harga provider)
+
+
+@dataclass
+class AgentContinue:
+    """LLM minta lanjut padahal batas iterasi tercapai.
+
+    Bukan error — TUI tampilkan ringkasan + tombol Lanjut/Berhenti.
+    CLI fallback: auto-lanjut kalau stdin bukan TTY? tidak — default berhenti.
+    Lihat run_agent(continue_on_limit) + main_screen._run_turn.
+    """
+
+    tool_count: int
+    limit: int
+    summary: str  # ringkasan tool terakhir biar user bisa nilai
+
+
+@dataclass
+class AgentError:
+    message: str
+
+
+AgentEvent = AgentText | AgentToolStart | AgentToolDone | AgentDone | AgentUsage | AgentContinue | AgentError
+
+
+if __name__ == "__main__":
+    evs: list[AgentEvent] = [
+        AgentText("halo"),
+        AgentToolStart("c1", "list_dir", {"path": "."}),
+        AgentToolDone("c1", "list_dir", True, {"success": True}),
+        AgentDone("selesai"),
+        AgentUsage(10, 5, 0.001),
+        AgentContinue(3, 3, "list_dir"),
+        AgentError("gagal"),
+    ]
+    assert len(evs) == 7
+    assert isinstance(evs[0], AgentText) and evs[0].delta == "halo"
+    assert isinstance(evs[5], AgentContinue) and evs[5].limit == 3
+    print("✅ agent_events self-test OK (7 event contract)")

{multacd-2.0.0b6 → multacd-2.0.0b8}/core/agent_loop.py

@@ -22,9 +22,18 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import AsyncIterator, Awaitable, Callable
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
+from core.agent_events import (
+    AgentContinue,
+    AgentDone,
+    AgentError,
+    AgentEvent,
+    AgentText,
+    AgentToolDone,
+    AgentToolStart,
+    AgentUsage,
+)
 from core.config import Config
 from core.llm_client import LLMClient, LLMError, StreamDone, StreamText, setup_client
 from core.permissions import PermissionChecker
@@ -54,46 +63,28 @@ AskCallback = Callable[[str], Awaitable[str]]
 OutputCallback = Callable[[str, str], None]
 
 
-@dataclass
-class AgentText:
-    delta: str
-
-
-@dataclass
-class AgentToolStart:
-    call_id: str
-    name: str
-    params: dict[str, Any]
-
-
-@dataclass
-class AgentToolDone:
-    call_id: str
-    name: str
-    success: bool
-    result: dict[str, Any] | None = None  # payload penuh (D4: expandable view)
-
-
-@dataclass
-class AgentDone:
-    text: str
-
-
-@dataclass
-class AgentUsage:
-    """Token resmi provider untuk satu panggilan LLM (0 = tak dilapor)."""
-
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    cost_usd: float = 0.0  # estimasi lokal (tabel harga provider)
-
-
-@dataclass
-class AgentError:
-    message: str
+# Re-export biar import lama (`from core.agent_loop import AgentText, ...`)
+# tetap jalan selama migrasi (R2: tanpa ubah behavior).
+__all__ = [
+    "AgentContinue",
+    "AgentDone",
+    "AgentError",
+    "AgentEvent",
+    "AgentText",
+    "AgentToolDone",
+    "AgentToolStart",
+    "AgentUsage",
+    "run_agent",
+]
 
 
-AgentEvent = AgentText | AgentToolStart | AgentToolDone | AgentDone | AgentUsage | AgentError
+def _stuck_error(tool_name: str) -> AgentError:
+    """Pesan stagnan: tool+args sama gagal error-sama 3x beruntun."""
+    return AgentError(
+        f"`{tool_name}` gagal dengan error yang sama 3x beruntun — "
+        "kemungkinan stuck. Coba pecah tugas jadi langkah kecil "
+        "atau kasih instruksi lebih spesifik."
+    )
 
 
 async def _stdin_confirm(tool_name: str, params: dict[str, Any]) -> str:
@@ -143,8 +134,23 @@ async def run_agent(
     active_tools: list[str] | None = None,
     composer: PromptComposer | None = None,
     output_cb: OutputCallback | None = None,
+    continue_on_limit: bool = False,
+    checker: PermissionChecker | None = None,
 ) -> AsyncIterator[AgentEvent]:
-    """Jalankan satu turn agent. Yield AgentEvent secara real-time."""
+    """Jalankan satu turn agent. Yield AgentEvent secara real-time.
+
+    Batas iterasi (ala opencode): tiap LLM round yang berisi tool call
+    = 1 step. Capai limit → yield AgentContinue (bukan AgentError).
+    TUI tanya user Lanjut/Berhenti; continue_on_limit=True (dipakai
+    retry lanjutan) langsung lanjut tanpa tanya. Infinite loop nyata
+    (LLM ngulang tool sama tanpa progres) tetap berhenti via deteksi
+    stagnan di bawah.
+
+    `checker` opsional biar pemilik sesi (AgentController) bisa pakai
+    satu PermissionChecker lintas turn — approve [A] jadi beneran
+    per-sesi, bukan hilang tiap turn (issue #32). Default None =
+    checker baru per turn (perilaku lama, dipakai CLI/test).
+    """
     def _system_prompt() -> str:
         return composer.compose() if composer is not None else SYSTEM_PROMPT
 
@@ -159,7 +165,7 @@ async def run_agent(
         return
 
     llm = llm_client or setup_client(config)
-    checker = PermissionChecker(config)
+    checker = checker or PermissionChecker(config)
     confirm_cb = confirm or _stdin_confirm
     ask_cb = ask_user or _stdin_ask
     defs = get_tool_definitions()
@@ -182,12 +188,48 @@ async def run_agent(
     context.add_message("user", user_input)
 
     iteration = 0
+    tool_rounds = 0  # round LLM yang berisi tool call (step ala opencode)
+    recent_names: list[str] = []  # nama tool terakhir (ringkasan Continue)
+    recent_fails: list[tuple[str, str, str]] = []  # (nama, args, err) stagnan
+
+    def _track_outcome(name: str, args: dict[str, Any],
+                       res: dict[str, Any]) -> bool:
+        """Catat hasil tool. True = stagnan: tool+args yang sama gagal
+        dengan error yang sama 3x beruntun (tanpa progres). Sukses atau
+        error yang beda = progres, tidak dihitung. Issue #28."""
+        import json as _js
+        try:
+            sig = _js.dumps(args, sort_keys=True, ensure_ascii=False,
+                            default=str)
+        except Exception:
+            sig = ""
+        err = str(res.get("error") or "").splitlines()
+        recent_fails.append((name, sig, err[0][:120] if err else ""))
+        if len(recent_fails) < 3:
+            return False
+        a, b, c = recent_fails[-3:]
+        return (a[0] == b[0] == c[0] and a[1] == b[1] == c[1]
+                and bool(a[2]) and a[2] == b[2] == c[2])
     while True:
         iteration += 1
-        if iteration > config.max_tool_iterations:
+        if iteration > config.max_tool_iterations and not continue_on_limit:
+            # Limit = proteksi, bukan vonis. Kasih user pilihan lanjut —
+            # opencode juga begini (lanjut tanpa reset konteks).
+            summary = ", ".join(recent_names[-3:]) or "(belum ada tool)"
+            yield AgentContinue(
+                tool_count=tool_rounds,
+                limit=config.max_tool_iterations,
+                summary=f"Batas {config.max_tool_iterations} iterasi tercapai "
+                        f"({tool_rounds} tool call: {summary}). "
+                        "Pilih Lanjut buat terusin, Berhenti buat sudahi.",
+            )
+            return
+        if iteration > config.max_tool_iterations * 3:
+            # Safety net absolut: 3x limit tanpa selesai = loop beneran.
             yield AgentError(
-                f"Mencapai batas {config.max_tool_iterations} iterasi tool. "
-                "Berhenti agar tidak infinite loop — coba pecah tugas jadi langkah kecil."
+                f"Berhenti setelah {config.max_tool_iterations * 3} iterasi "
+                "tanpa selesai — kemungkinan infinite loop. "
+                "Coba pecah tugas jadi langkah kecil."
             )
             return
 
@@ -218,9 +260,12 @@ async def run_agent(
             yield AgentDone(done.text)
             return
 
+        tool_rounds += 1
+
         # ── Act + Observe: proses tiap tool call ──
         for call in done.tool_calls:
             yield AgentToolStart(call.id, call.name, call.arguments)
+            recent_names.append(call.name)
 
             # Tool "ask" dicegat: jawab via callback, bukan execute_tool (stdin).
             if call.name == "ask":
@@ -229,6 +274,7 @@ async def run_agent(
                 ask_result = {"success": True, "result": answer, "error": None}
                 context.add_tool_result(call.id, "ask", ask_result)
                 yield AgentToolDone(call.id, "ask", True, ask_result)
+                _track_outcome("ask", call.arguments, ask_result)
                 continue
 
             decision = checker.check(call.name, call.arguments)
@@ -237,6 +283,9 @@ async def run_agent(
                     f"Tool `{call.name}` tidak tersedia. Pakai tool dari daftar yang ada.")
                 context.add_tool_result(call.id, call.name, deny_result)
                 yield AgentToolDone(call.id, call.name, False, deny_result)
+                if _track_outcome(call.name, call.arguments, deny_result):
+                    yield _stuck_error(call.name)
+                    return
                 continue
 
             if decision == "ask":
@@ -270,6 +319,9 @@ async def run_agent(
                         if not made.get("success"):
                             context.add_tool_result(call.id, call.name, made)
                             yield AgentToolDone(call.id, call.name, False, made)
+                            if _track_outcome(call.name, call.arguments, made):
+                                yield _stuck_error(call.name)
+                                return
                             continue
                         call.arguments["branch"] = new_branch
                         call.arguments.pop("allow_protected", None)
@@ -280,6 +332,9 @@ async def run_agent(
                         "cari cara lain atau tanya user.")
                     context.add_tool_result(call.id, call.name, cancel_result)
                     yield AgentToolDone(call.id, call.name, False, cancel_result)
+                    if _track_outcome(call.name, call.arguments, cancel_result):
+                        yield _stuck_error(call.name)
+                        return
                     continue
 
             # to_thread: tool sync jalan di thread, event loop tetap hidup.
@@ -294,6 +349,9 @@ async def run_agent(
                 _live if output_cb is not None else None)
             context.add_tool_result(call.id, call.name, result)
             yield AgentToolDone(call.id, call.name, result["success"], result)
+            if _track_outcome(call.name, call.arguments, result):
+                yield _stuck_error(call.name)
+                return
 
 
 if __name__ == "__main__":
@@ -389,13 +447,49 @@ if __name__ == "__main__":
         assert "tidak tersedia" in ctx.get_messages()[-2]["content"]
         assert isinstance(events[-1], AgentDone)
 
-        # 6. Infinite loop → berhenti di batas
+        # 6. Limit → AgentContinue (bukan error): user bisa lanjut.
+        # continue_on_limit=True = lanjutan tanpa tanya (dipakai TUI).
+        # NOTE: jangan import ulang core.agent_loop di sini (double-import
+        # trap python -m: kelas ganda, isinstance gagal). Pakai nama lokal.
         cfg2 = Config(model="m", api_key="k", max_tool_iterations=3)
         fake = FakeLLM([StreamDone("", [_TCR("c9", "list_dir", {})])] * 10)
         ctx = ConversationContext()
         events = await _drain(run_agent("loop", ctx, cfg2, llm_client=fake,
                                         confirm=_no_confirm))
-        assert isinstance(events[-1], AgentError) and "3 iterasi" in events[-1].message
+        assert isinstance(events[-1], AgentContinue), events[-1]
+        assert events[-1].limit == 3 and events[-1].tool_count == 3
+        assert "list_dir" in events[-1].summary
+        # Lanjutan: konteks utuh, loop terus sampai LLM selesai.
+        # 5 tool (< 3x limit=9) lalu selesai → AgentDone, bukan safety net.
+        fake = FakeLLM([StreamDone("", [_TCR("c9", "list_dir", {})])] * 5
+                       + [StreamDone("akhirnya selesai", [])])
+        ctx = ConversationContext()
+        events = await _drain(run_agent("loop", ctx, cfg2, llm_client=fake,
+                                        confirm=_no_confirm,
+                                        continue_on_limit=True))
+        assert isinstance(events[-1], AgentDone), events[-1]
+        assert "selesai" in events[-1].text
+        # Safety net absolut: 3x limit tanpa selesai = error beneran.
+        # Pakai call SUKSES berulang (stagnan cuma bunuh gagal-sama-3x).
+        fake = FakeLLM([StreamDone("", [_TCR("c9", "list_dir", {})])] * 100)
+        ctx = ConversationContext()
+        events = await _drain(run_agent("loop", ctx, cfg2, llm_client=fake,
+                                        confirm=_no_confirm,
+                                        continue_on_limit=True))
+        assert isinstance(events[-1], AgentError), events[-1]
+        assert "9 iterasi" in events[-1].message
+
+        # 6b. Stagnan: tool+args sama GAGAL error-sama 3x → setop.
+        # Sukses berulang = progres (retry), tidak dihitung.
+        cfg3 = Config(model="m", api_key="k", max_tool_iterations=20)
+        fake = FakeLLM([StreamDone("", [_TCR("c1", "read_file",
+                                            {"path": "a.py"})])] * 5)
+        ctx = ConversationContext()
+        events = await _drain(run_agent("stuck", ctx, cfg3, llm_client=fake,
+                                        confirm=_no_confirm))
+        assert isinstance(events[-1], AgentError), events[-1]
+        assert "3x" in events[-1].message and "read_file" in events[-1].message
+        # Sukses-sama 3x = bukan stagnan (dibuktikan skenario 6 lanjutan).
 
         # 7. Tool ask() dicegat via callback (tanpa stdin)
         async def _answer(q):

{multacd-2.0.0b6 → multacd-2.0.0b8}/core/config.py

@@ -128,6 +128,12 @@ SCHEDULE_ACTIONS = ("briefing", "research")
 
 
 def _str(loc: str, v: object, errs: list[str], min_len: int = 0) -> str:
+    # YAML `key:` kosong → None. Field opsional (min_len=0) maafkan jadi "",
+    # field wajib tetap error tapi pesannya "wajib diisi", bukan "NoneType".
+    if v is None:
+        if min_len > 0:
+            errs.append(f"{loc}: wajib diisi (kosong)")
+        return ""
     if isinstance(v, bool) or not isinstance(v, (str, int, float)):
         errs.append(f"{loc}: harus teks, dapat {type(v).__name__}")
         return "" if isinstance(v, str) else str(v) if v is not None else ""
@@ -140,9 +146,9 @@ def _str(loc: str, v: object, errs: list[str], min_len: int = 0) -> str:
 def _int(loc: str, v: object, errs: list[str], gt: int | None = None,
          le: int | None = None) -> int:
     n: int | None = None
-    if isinstance(v, bool):
-        pass
-    elif isinstance(v, int):
+    if v is None or (isinstance(v, str) and not v.strip()):
+        n = 0  # key kosong = 0; lolos kalau opsional, error gt/le kalau wajib
+    elif isinstance(v, int) and not isinstance(v, bool):
         n = v
     elif isinstance(v, str) and v.strip().lstrip("+-").isdigit():
         n = int(v.strip())
@@ -159,9 +165,9 @@ def _int(loc: str, v: object, errs: list[str], gt: int | None = None,
 def _float(loc: str, v: object, errs: list[str], ge: float | None = None,
            le: float | None = None) -> float:
     f: float | None = None
-    if isinstance(v, bool):
-        pass
-    elif isinstance(v, (int, float)):
+    if v is None or (isinstance(v, str) and not v.strip()):
+        f = 0.0  # key kosong = 0.0; lolos kalau opsional, error ge/le kalau wajib
+    elif isinstance(v, (int, float)) and not isinstance(v, bool):
         f = float(v)
     elif isinstance(v, str):
         try:
@@ -179,6 +185,8 @@ def _float(loc: str, v: object, errs: list[str], ge: float | None = None,
 
 
 def _bool(loc: str, v: object, errs: list[str]) -> bool:
+    if v is None:
+        return False  # key kosong = default False (opsional)
     if isinstance(v, bool):
         return v
     if isinstance(v, str) and v.strip().lower() in (
@@ -190,6 +198,8 @@ def _bool(loc: str, v: object, errs: list[str]) -> bool:
 
 def _choice(loc: str, v: object, errs: list[str], options: tuple[str, ...],
             normalize: bool = False) -> str:
+    if v is None:
+        return options[0]  # key kosong = default opsi pertama
     s = v.lower().strip() if normalize and isinstance(v, str) else v
     if not isinstance(s, str) or s not in options:
         errs.append(f"{loc}: harus salah satu dari {', '.join(options)}, "
@@ -198,6 +208,24 @@ def _choice(loc: str, v: object, errs: list[str], options: tuple[str, ...],
     return s
 
 
+def _strmap(loc: str, v: object, errs: list[str]) -> dict[str, str]:
+    """Dict str→str (provider_keys/bases). None → {}. Key dilower-case,
+    value kosong dibuang. Bukan mapping / value bukan str = error."""
+    if v is None:
+        return {}
+    if not isinstance(v, dict):
+        errs.append(f"{loc}: harus mapping, dapat {type(v).__name__}")
+        return {}
+    out: dict[str, str] = {}
+    for k, val in v.items():
+        if not isinstance(k, str) or not isinstance(val, str):
+            errs.append(f"{loc}.{k}: key dan value harus teks")
+            continue
+        if val.strip():
+            out[k.lower().strip()] = val
+    return out
+
+
 def _raise_if_errors(errs: list[str]) -> None:
     if errs:
         raise ConfigError("config tidak valid: " + "; ".join(errs), errs)
@@ -213,11 +241,14 @@ class TelegramConfig:
     allowed_users: list[int] = field(default_factory=list)
 
     def __post_init__(self) -> None:
+        # Normalisasi None sudah ditangani _str/_int (key kosong → default).
         errs: list[str] = []
         self.bot_token = _str("telegram.bot_token", self.bot_token, errs)
         self.admin_id = _int("telegram.admin_id", self.admin_id, errs)
         self.admin_username = _str("telegram.admin_username",
                                    self.admin_username, errs)
+        if self.allowed_users is None:
+            self.allowed_users = []  # `allowed_users:` kosong = []
         if not isinstance(self.allowed_users, list):
             errs.append(f"telegram.allowed_users: harus list, "
                         f"dapat {self.allowed_users!r}")
@@ -270,6 +301,9 @@ class BriefingConfig:
         self.news = _bool("briefing.news", self.news, errs)
         self.git_status = _bool("briefing.git_status", self.git_status, errs)
         self.weather = _bool("briefing.weather", self.weather, errs)
+        if self.news_topics is None:
+            self.news_topics = ["artificial intelligence",
+                                "software engineering"]
         if not isinstance(self.news_topics, list) or not all(
                 isinstance(t, str) for t in self.news_topics):
             errs.append("briefing.news_topics: harus list of string")
@@ -283,6 +317,8 @@ def _nested(loc: str, cls: type, v: object, errs: list[str]) -> object:
     """Dict → dataclass nested. Error nested digabung ke errs caller."""
     if isinstance(v, cls):
         return v
+    if v is None:
+        return cls()  # `telegram:` kosong tanpa isi = pakai default (nonaktif)
     if isinstance(v, dict):
         known = {f.name for f in fields(cls)}
         try:
@@ -302,6 +338,10 @@ class Config:
     model: str = ""
     api_key: str = ""
     api_base: str | None = None
+    # Key/base per provider (#31): {"openai": "sk-...", ...}. Dipakai saat
+    # model pindah provider; fallback = api_key/api_base top-level.
+    provider_keys: dict = field(default_factory=dict)
+    provider_bases: dict = field(default_factory=dict)
 
     # ── Agent settings ──
     max_tokens: int = 8096
@@ -345,6 +385,10 @@ class Config:
         self.api_key = _str("api_key", self.api_key, errs, min_len=1)
         if self.api_base is not None:
             self.api_base = _str("api_base", self.api_base, errs)
+        self.provider_keys = _strmap("provider_keys", self.provider_keys,
+                                     errs)
+        self.provider_bases = _strmap("provider_bases", self.provider_bases,
+                                      errs)
         self.max_tokens = _int("max_tokens", self.max_tokens, errs, gt=0)
         self.temperature = _float("temperature", self.temperature, errs,
                                   ge=0.0, le=2.0)
@@ -398,6 +442,8 @@ class Config:
                                                errs)
         self.telegram = _nested("telegram", TelegramConfig,
                                 self.telegram, errs)
+        if self.schedules is None:
+            self.schedules = []  # `schedules:` kosong = []
         if not isinstance(self.schedules, list):
             errs.append(f"schedules: harus list, "
                         f"dapat {type(self.schedules).__name__}")
@@ -484,6 +530,37 @@ def config_from_dict(raw: dict) -> Config:
     return Config(**{k: v for k, v in raw.items() if k in known})
 
 
+def save_config_updates(updates: dict,
+                        explicit_path: Path | str | None = None) -> None:
+    """Merge updates ke config.yaml lalu tulis (buat /model /key /base).
+
+    Dict di-merge per-key (provider_keys lama dipertahankan), sisanya
+    replace. Raise OSError kalau gagal tulis — caller yang berpesan.
+    """
+    path = resolve_config_path(explicit_path)
+    try:
+        raw = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except (OSError, UnicodeDecodeError, yaml.YAMLError):
+        raw = {}
+    if not isinstance(raw, dict):
+        raw = {}
+    for k, v in updates.items():
+        if isinstance(v, dict) and isinstance(raw.get(k), dict):
+            merged = dict(raw[k])
+            for mk, mv in v.items():
+                # "" / None = hapus key (dipakai `/base -`).
+                if mv is None or (isinstance(mv, str) and not mv.strip()):
+                    merged.pop(mk, None)
+                else:
+                    merged[mk] = mv
+            raw[k] = merged
+        else:
+            raw[k] = v
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(raw, sort_keys=False, allow_unicode=True),
+                    encoding="utf-8")
+
+
 def load_config(explicit_path: Path | str | None = None) -> Config:
     """Baca & validasi config. Exit(1) dengan pesan jelas kalau ada masalah."""
     path = resolve_config_path(explicit_path)

{multacd-2.0.0b6 → multacd-2.0.0b8}/core/llm_client.py

@@ -33,6 +33,7 @@ from core.providers import (
     ProviderError,
     ProviderNotFoundError,
     ProviderRateLimitError,
+    provider_id_of,
     resolve_provider,
 )
 
@@ -102,7 +103,13 @@ class LLMClient:
         langsung raise LLMError.
         """
         try:
-            spec = resolve_provider(self.config.model, self.config.api_base)
+            prov = provider_id_of(self.config.model)
+            # Key/base per-provider (#31); fallback = top-level (kompat).
+            api_key = (self.config.provider_keys.get(prov)
+                       or self.config.api_key) if prov else self.config.api_key
+            api_base = (self.config.provider_bases.get(prov)
+                        or self.config.api_base) if prov else self.config.api_base
+            spec = resolve_provider(self.config.model, api_base)
         except ProviderError as e:
             raise LLMError(str(e)) from e
         if spec.kind == "anthropic":
@@ -116,7 +123,7 @@ class LLMClient:
             yielded_any_text = False
             try:
                 async for event in stream_chat(
-                        spec, self.config.api_key, messages, tools,
+                        spec, api_key, messages, tools,
                         self.config.max_tokens, self.config.temperature,
                         REQUEST_TIMEOUT):
                     if isinstance(event, StreamText) and event.content: