machinaos 0.0.78 → 0.0.80

package/server/services/cli_agent/types.py

@@ -17,15 +17,15 @@ from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from services.cli_agent.protocol import CanonicalUsage
-
 
 # ---------------------------------------------------------------------------
 # Task specs (discriminated union)
 # ---------------------------------------------------------------------------
 
+
 class BaseAICliTaskSpec(BaseModel):
     """Shared fields for every CLI task."""
+
     task_id: Optional[str] = Field(
         default=None,
         description="Auto-assigned `t_<8hex>` if omitted.",
@@ -37,15 +37,16 @@ class BaseAICliTaskSpec(BaseModel):
     )
     branch: Optional[str] = Field(
         default=None,
-        description="Branch name for the per-task git worktree. "
-                    "Auto-named `machina/<task_id>` if omitted.",
+        description="Branch name for the per-task git worktree. " "Auto-named `machina/<task_id>` if omitted.",
     )
     model: Optional[str] = Field(default=None)
     timeout_seconds: int = Field(
-        default=600, ge=10, le=3600,
+        default=600,
+        ge=10,
+        le=3600,
         description="Hard timeout per task. On expiry the session is "
-                    "terminate_then_kill'd and a diagnostic dump is "
-                    "written to ~/.claude-machina/logs/.",
+        "terminate_then_kill'd and a diagnostic dump is "
+        "written to ~/.claude-machina/logs/.",
     )
     system_prompt: Optional[str] = Field(
         default=None,
@@ -61,31 +62,51 @@ class BaseAICliTaskSpec(BaseModel):
 class ClaudeTaskSpec(BaseAICliTaskSpec):
     """Claude Code CLI task. Full feature set: sessions, resume, budget,
     turns, allowed_tools, permission_mode."""
+
     provider: Literal["claude"] = "claude"
     session_id: Optional[str] = Field(
         default=None,
         description="Start a named session. Pair with `resume_session_id` "
-                    "to chain conversations.",
+        "to chain conversations. Note: silently dropped in "
+        "interactive mode (claude assigns its own UUID); "
+        "kept for back-compat.",
     )
     resume_session_id: Optional[str] = Field(
         default=None,
-        description="Resume from a prior session_id (returned in a previous "
-                    "task's `result` event).",
+        description="Resume from a specific prior session UUID. Mutually "
+        "exclusive with `continue_session`. Generally unset by "
+        "claude_code_agent — set `continue_session=True` for "
+        "memory-bound runs and let claude find its own latest.",
+    )
+    continue_session: bool = Field(
+        default=False,
+        description="Emit `--continue` so claude auto-loads the most "
+        "recent conversation under the current cwd (per "
+        "code.claude.com/docs/en/cli-reference). The cleaner "
+        "alternative to passing a specific UUID via "
+        "`resume_session_id` — claude handles session "
+        "tracking itself, no UUID round-trip through the "
+        "memory node's params required.",
     )
     max_turns: Optional[int] = Field(
-        default=None, ge=1,
+        default=None,
+        ge=1,
         description="Per-task turn cap. Defaults to provider config.",
     )
     max_budget_usd: Optional[float] = Field(
-        default=None, ge=0,
+        default=None,
+        ge=0,
         description="Per-task USD budget. Defaults to provider config.",
     )
     allowed_tools: Optional[str] = Field(
         default=None,
-        description="Comma-separated tool list. Defaults to "
-                    "Read,Edit,Bash,Glob,Grep,Write.",
+        description="Comma-separated tool list. Default is empty — "
+        "claude built-ins (Read/Edit/Bash/Glob/Grep/Write/"
+        "Skill/WebSearch/WebFetch) are intentionally NOT in "
+        "the allowlist; the agent only gets connected MCP "
+        "tools + MachinaOs's own MCP infrastructure tools.",
     )
-    permission_mode: Literal["default", "acceptEdits", "plan", "auto", "dontAsk", "bypassPermissions"] = "acceptEdits"
+    permission_mode: Literal["default", "acceptEdits", "plan", "auto", "dontAsk", "bypassPermissions"] = "dontAsk"
 
     # ---- optional documented CLI flags (cli-reference) ----
     effort: Optional[Literal["low", "medium", "high", "xhigh", "max"]] = Field(
@@ -112,10 +133,9 @@ class ClaudeTaskSpec(BaseAICliTaskSpec):
 
 class CodexTaskSpec(BaseAICliTaskSpec):
     """OpenAI Codex CLI task. Sandbox-first; no session/resume/budget/turns."""
+
     provider: Literal["codex"] = "codex"
-    sandbox: Literal["read-only", "workspace-write", "danger-full-access"] = (
-        "workspace-write"
-    )
+    sandbox: Literal["read-only", "workspace-write", "danger-full-access"] = "workspace-write"
     ask_for_approval: Literal["untrusted", "on-request", "never"] = "never"
 
 
@@ -125,6 +145,7 @@ class GeminiTaskSpec(BaseAICliTaskSpec):
     Schema lives in v1 so the discriminated union JSON Schema for the
     LLM tool fast-path doesn't change when v2 lands.
     """
+
     provider: Literal["gemini"] = "gemini"
     session_id: Optional[str] = None
     resume: Optional[str] = Field(
@@ -145,8 +166,10 @@ AICliTaskSpec = Annotated[
 # Result models (Pydantic for serialisation; mirror dataclasses in protocol.py)
 # ---------------------------------------------------------------------------
 
+
 class CanonicalUsagePydantic(BaseModel):
     """Pydantic mirror of `protocol.CanonicalUsage` for output serialisation."""
+
     input_tokens: int = 0
     output_tokens: int = 0
     cache_read: int = 0
@@ -157,6 +180,7 @@ class CanonicalUsagePydantic(BaseModel):
 
 class SessionResultModel(BaseModel):
     """Per-task result, JSON-serialisable."""
+
     task_id: str
     session_id: Optional[str] = None
     provider: str = ""
@@ -178,6 +202,7 @@ class SessionResultModel(BaseModel):
 
 class BatchSummary(BaseModel):
     """Aggregated batch summary."""
+
     n_tasks: int = 0
     n_succeeded: int = 0
     n_failed: int = 0
@@ -188,6 +213,7 @@ class BatchSummary(BaseModel):
 
 class BatchResultModel(BaseModel):
     """Top-level batch result returned by `run_batch()`."""
+
     tasks: List[SessionResultModel] = Field(default_factory=list)
     summary: BatchSummary = Field(default_factory=BatchSummary)
     provider: str = ""
@@ -198,6 +224,7 @@ class BatchResultModel(BaseModel):
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def session_result_to_model(sr: Any) -> SessionResultModel:
     """Convert a `protocol.SessionResult` dataclass to its Pydantic mirror."""
     cu = CanonicalUsagePydantic(

package/server/services/cli_agent/workflow_tools.py

@@ -63,9 +63,9 @@ def expose_workflow_tools(connected_tools: List[Dict[str, Any]]) -> None:
         try:
             handler = _build_handler(node_type, cls.Params)
             mcp.add_tool(
-                handler, name=node_type,
-                description=(getattr(cls, "description", None)
-                             or f"MachinaOs workflow tool: {node_type}"),
+                handler,
+                name=node_type,
+                description=(getattr(cls, "description", None) or f"MachinaOs workflow tool: {node_type}"),
             )
             logger.info("[CC-Agent MCP] exposed mcp__machinaos__%s", node_type)
         except Exception as exc:  # pragma: no cover
@@ -99,9 +99,11 @@ def unexpose_workflow_tools(connected_tools: List[Dict[str, Any]]) -> None:
 # Internals
 # ---------------------------------------------------------------------------
 
+
 def _get_mcp() -> Optional[Any]:
     """Late import to avoid a circular import with ``mcp_server``."""
     from services.cli_agent import mcp_server
+
     return mcp_server._mcp_singleton
 
 
@@ -130,10 +132,7 @@ def _schedule_list_changed_notify() -> None:
 
     async def _do_notify() -> None:
         try:
-            session = (
-                getattr(mcp, "session", None)
-                or getattr(getattr(mcp, "_mcp_server", None), "session", None)
-            )
+            session = getattr(mcp, "session", None) or getattr(getattr(mcp, "_mcp_server", None), "session", None)
             if session is not None and hasattr(session, "send_tool_list_changed"):
                 await session.send_tool_list_changed()
         except Exception as exc:
@@ -168,13 +167,18 @@ def _build_handler(node_type: str, params_cls: type):
             default = None
         else:
             default = finfo.default
-        parameters.append(inspect.Parameter(
-            fname, inspect.Parameter.KEYWORD_ONLY,
-            annotation=finfo.annotation, default=default,
-        ))
+        parameters.append(
+            inspect.Parameter(
+                fname,
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=finfo.annotation,
+                default=default,
+            )
+        )
 
     async def _handler(**kwargs: Any) -> Dict[str, Any]:
         from services.cli_agent.mcp_server import _require_batch
+
         ctx = _require_batch()
         entry = next(
             (t for t in ctx.connected_tools if t.get("node_type") == node_type),
@@ -195,9 +199,13 @@ def _build_handler(node_type: str, params_cls: type):
             args = dict(kwargs)
         logger.info(
             "[CC-Agent MCP %s] node=%s wf=%s args_keys=%s",
-            node_type, ctx.node_id, ctx.workflow_id, list(args.keys()),
+            node_type,
+            ctx.node_id,
+            ctx.workflow_id,
+            list(args.keys()),
         )
         from services.handlers.tools import execute_tool
+
         config: Dict[str, Any] = {
             "node_type": node_type,
             "node_id": entry.get("node_id"),
@@ -211,19 +219,24 @@ def _build_handler(node_type: str, params_cls: type):
         if "error" in result:
             logger.warning(
                 "[CC-Agent MCP %s] node=%s ERROR: %s",
-                node_type, entry.get("node_id"), result.get("error"),
+                node_type,
+                entry.get("node_id"),
+                result.get("error"),
             )
         else:
             logger.info(
                 "[CC-Agent MCP %s] node=%s OK (result_keys=%s)",
-                node_type, entry.get("node_id"), list(result.keys())[:8],
+                node_type,
+                entry.get("node_id"),
+                list(result.keys())[:8],
             )
         return result
 
     _handler.__name__ = node_type
     _handler.__annotations__ = annotations
     _handler.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
-        parameters, return_annotation=Dict[str, Any],
+        parameters,
+        return_annotation=Dict[str, Any],
     )
     return _handler
 

package/server/services/compaction.py

@@ -39,13 +39,13 @@ def _extract_text_from_response(content) -> str:
         text_parts = []
         for block in content:
             if isinstance(block, dict):
-                if block.get('type') == 'text' and block.get('text'):
-                    text_parts.append(block['text'])
-                elif 'text' in block:
-                    text_parts.append(str(block['text']))
+                if block.get("type") == "text" and block.get("text"):
+                    text_parts.append(block["text"])
+                elif "text" in block:
+                    text_parts.append(str(block["text"]))
             elif isinstance(block, str):
                 text_parts.append(block)
-        return '\n'.join(text_parts)
+        return "\n".join(text_parts)
 
     # Handle string content
     if isinstance(content, str):
@@ -57,6 +57,7 @@ def _extract_text_from_response(content) -> str:
 
 class CompactionConfig(BaseModel):
     """Provider-agnostic compaction configuration."""
+
     enabled: bool = True
 
 
@@ -76,6 +77,7 @@ class CompactionService:
         """Per-user override from ``user_settings.compaction_ratio``, falling
         back to ``agent.compaction.ratio`` in ``llm_defaults.json``."""
         from services.model_registry import get_model_registry
+
         try:
             settings = await self._db.get_user_settings("default")
             if settings and "compaction_ratio" in settings:
@@ -95,6 +97,7 @@ class CompactionService:
         wins over the value returned here.
         """
         from services.model_registry import get_model_registry
+
         registry = get_model_registry()
         if ratio is None:
             ratio = float(registry.get_agent_defaults()["compaction"]["ratio"])
@@ -108,10 +111,7 @@ class CompactionService:
         if not threshold:
             ratio = await self._get_compaction_ratio()
             threshold = self.get_model_threshold(model, provider, ratio=ratio)
-        return {
-            "enabled": self._config.enabled,
-            "context_token_threshold": threshold
-        }
+        return {"enabled": self._config.enabled, "context_token_threshold": threshold}
 
     async def anthropic_api_config(self, threshold: Optional[int] = None, model: str = "", provider: str = "anthropic") -> Dict[str, Any]:
         """Anthropic Messages API context_management config."""
@@ -120,12 +120,7 @@ class CompactionService:
             threshold = self.get_model_threshold(model, provider, ratio=ratio)
         return {
             "betas": ["compact-2026-01-12"],
-            "context_management": {
-                "edits": [{
-                    "type": "compact_20260112",
-                    "trigger": {"type": "input_tokens", "value": threshold}
-                }]
-            }
+            "context_management": {"edits": [{"type": "compact_20260112", "trigger": {"type": "input_tokens", "value": threshold}}]},
         }
 
     async def openai_config(self, threshold: Optional[int] = None, model: str = "", provider: str = "openai") -> Dict[str, Any]:
@@ -146,35 +141,40 @@ class CompactionService:
             output_tokens=usage.get("output_tokens", 0),
             cache_read_tokens=usage.get("cache_read_tokens", 0),
             cache_creation_tokens=usage.get("cache_creation_tokens", 0),
-            reasoning_tokens=usage.get("reasoning_tokens", 0)
+            reasoning_tokens=usage.get("reasoning_tokens", 0),
         )
 
         # Save token metric with cost fields
-        await self._db.save_token_metric({
-            "session_id": session_id,
-            "node_id": node_id,
-            "provider": provider,
-            "model": model,
-            **usage,
-            "input_cost": cost["input_cost"],
-            "output_cost": cost["output_cost"],
-            "cache_cost": cost["cache_cost"],
-            "total_cost": cost["total_cost"]
-        })
+        await self._db.save_token_metric(
+            {
+                "session_id": session_id,
+                "node_id": node_id,
+                "provider": provider,
+                "model": model,
+                **usage,
+                "input_cost": cost["input_cost"],
+                "output_cost": cost["output_cost"],
+                "cache_cost": cost["cache_cost"],
+                "total_cost": cost["total_cost"],
+            }
+        )
 
         state = await self._db.get_or_create_session_token_state(session_id)
         new_total = state["cumulative_total"] + usage.get("total_tokens", 0)
         new_total_cost = state.get("cumulative_total_cost", 0.0) + cost["total_cost"]
 
         # Update cumulative state with cost
-        await self._db.update_session_token_state(session_id, {
-            "cumulative_input_tokens": state["cumulative_input_tokens"] + usage.get("input_tokens", 0),
-            "cumulative_output_tokens": state["cumulative_output_tokens"] + usage.get("output_tokens", 0),
-            "cumulative_total": new_total,
-            "cumulative_input_cost": state.get("cumulative_input_cost", 0.0) + cost["input_cost"],
-            "cumulative_output_cost": state.get("cumulative_output_cost", 0.0) + cost["output_cost"],
-            "cumulative_total_cost": new_total_cost
-        })
+        await self._db.update_session_token_state(
+            session_id,
+            {
+                "cumulative_input_tokens": state["cumulative_input_tokens"] + usage.get("input_tokens", 0),
+                "cumulative_output_tokens": state["cumulative_output_tokens"] + usage.get("output_tokens", 0),
+                "cumulative_total": new_total,
+                "cumulative_input_cost": state.get("cumulative_input_cost", 0.0) + cost["input_cost"],
+                "cumulative_output_cost": state.get("cumulative_output_cost", 0.0) + cost["output_cost"],
+                "cumulative_total_cost": new_total_cost,
+            },
+        )
 
         # Priority: per-session custom > model-aware (with user ratio) > global default
         custom = state.get("custom_threshold")
@@ -186,6 +186,7 @@ class CompactionService:
 
         # Get the model's full context window size for frontend display
         from services.model_registry import get_model_registry
+
         registry = get_model_registry()
         context_length = registry.get_context_length(model, provider)
 
@@ -195,22 +196,35 @@ class CompactionService:
             "cost": cost,
             "threshold": threshold,
             "context_length": context_length,
-            "needs_compaction": self._config.enabled and new_total >= threshold
+            "needs_compaction": self._config.enabled and new_total >= threshold,
         }
 
-    async def record(self, session_id: str, node_id: str, provider: str, model: str, tokens_before: int, tokens_after: int, summary: Optional[str] = None) -> None:
+    async def record(
+        self, session_id: str, node_id: str, provider: str, model: str, tokens_before: int, tokens_after: int, summary: Optional[str] = None
+    ) -> None:
         """Record compaction event after native API handles it."""
         state = await self._db.get_or_create_session_token_state(session_id)
-        await self._db.save_compaction_event({
-            "session_id": session_id, "node_id": node_id, "trigger_reason": "native",
-            "tokens_before": tokens_before, "tokens_after": tokens_after,
-            "summary_model": model, "summary_provider": provider, "success": True, "summary_content": summary
-        })
-        await self._db.update_session_token_state(session_id, {
-            "cumulative_total": tokens_after,
-            "last_compaction_at": datetime.now(timezone.utc),
-            "compaction_count": state["compaction_count"] + 1
-        })
+        await self._db.save_compaction_event(
+            {
+                "session_id": session_id,
+                "node_id": node_id,
+                "trigger_reason": "native",
+                "tokens_before": tokens_before,
+                "tokens_after": tokens_after,
+                "summary_model": model,
+                "summary_provider": provider,
+                "success": True,
+                "summary_content": summary,
+            }
+        )
+        await self._db.update_session_token_state(
+            session_id,
+            {
+                "cumulative_total": tokens_after,
+                "last_compaction_at": datetime.now(timezone.utc),
+                "compaction_count": state["compaction_count"] + 1,
+            },
+        )
 
     async def stats(self, session_id: str, model: str = "", provider: str = "") -> Dict[str, Any]:
         """Get session statistics.
@@ -229,6 +243,7 @@ class CompactionService:
         context_length = 0
         if model and provider:
             from services.model_registry import get_model_registry
+
             registry = get_model_registry()
             context_length = registry.get_context_length(model, provider)
 
@@ -299,17 +314,16 @@ Provide a concise but complete summary."""
 
             # Use a reasonable summary size: min(4096, model's max output)
             from services.model_registry import get_model_registry
+
             model_max = get_model_registry().get_max_output_tokens(model, provider)
             summary_tokens = min(4096, model_max)
 
-            llm = self._ai_service.create_model(
-                provider=provider, api_key=api_key, model=model,
-                temperature=0.3, max_tokens=summary_tokens
-            )
+            llm = self._ai_service.create_model(provider=provider, api_key=api_key, model=model, temperature=0.3, max_tokens=summary_tokens)
 
             from langchain_core.messages import HumanMessage
+
             response = await llm.ainvoke([HumanMessage(content=prompt)])
-            raw_content = response.content if hasattr(response, 'content') else str(response)
+            raw_content = response.content if hasattr(response, "content") else str(response)
             summary = _extract_text_from_response(raw_content)
 
             new_memory = f"# Conversation Summary (Compacted)\n*Generated: {datetime.now(timezone.utc).isoformat()}*\n\n{summary}"
@@ -326,9 +340,11 @@ Provide a concise but complete summary."""
 
 _service: Optional[CompactionService] = None
 
+
 def get_compaction_service() -> Optional[CompactionService]:
     return _service
 
+
 def init_compaction_service(database: "Database", settings: "Settings") -> CompactionService:
     global _service
     _service = CompactionService(database, settings)

package/server/services/credential_registry.py

@@ -64,13 +64,9 @@ class CredentialRegistry:
                 with _CONFIG_PATH.open(encoding="utf-8") as f:
                     self._raw = json.load(f)
             except FileNotFoundError as e:
-                raise CredentialRegistryError(
-                    f"credential_providers.json not found at {_CONFIG_PATH}"
-                ) from e
+                raise CredentialRegistryError(f"credential_providers.json not found at {_CONFIG_PATH}") from e
             except json.JSONDecodeError as e:
-                raise CredentialRegistryError(
-                    f"credential_providers.json is not valid JSON: {e}"
-                ) from e
+                raise CredentialRegistryError(f"credential_providers.json is not valid JSON: {e}") from e
         return self._raw
 
     def _resolve_all(self) -> Dict[str, Dict[str, Any]]:
@@ -98,13 +94,10 @@ class CredentialRegistry:
         """Walk the extends chain, deep-merge parent then child overrides."""
         if provider_id in visiting:
             raise CredentialRegistryError(
-                f"extends cycle detected involving provider {provider_id!r}: "
-                f"{' -> '.join(sorted(visiting))} -> {provider_id}"
+                f"extends cycle detected involving provider {provider_id!r}: " f"{' -> '.join(sorted(visiting))} -> {provider_id}"
             )
         if provider_id not in raw:
-            raise CredentialRegistryError(
-                f"provider {provider_id!r} referenced via extends but not defined"
-            )
+            raise CredentialRegistryError(f"provider {provider_id!r} referenced via extends but not defined")
 
         entry = raw[provider_id]
         extends = entry.get("extends")
@@ -158,10 +151,7 @@ class CredentialRegistry:
         categories = raw.get("categories", {})
         if not isinstance(categories, dict):
             return []
-        out = [
-            {"key": key, "label": cfg.get("label", key), "order": cfg.get("order", 0)}
-            for key, cfg in categories.items()
-        ]
+        out = [{"key": key, "label": cfg.get("label", key), "order": cfg.get("order", 0)} for key, cfg in categories.items()]
         out.sort(key=lambda c: (c["order"], c["key"]))
         return out
 
@@ -238,11 +228,7 @@ def _deep_merge(parent: Dict[str, Any], child: Dict[str, Any]) -> Dict[str, Any]
         parent_value = result.get(key)
         if isinstance(parent_value, dict) and isinstance(child_value, dict):
             result[key] = _deep_merge(parent_value, child_value)
-        elif (
-            key in _MERGE_BY_KEY_ARRAYS
-            and isinstance(parent_value, list)
-            and isinstance(child_value, list)
-        ):
+        elif key in _MERGE_BY_KEY_ARRAYS and isinstance(parent_value, list) and isinstance(child_value, list):
             result[key] = _merge_array_by_key(parent_value, child_value)
         else:
             result[key] = copy.deepcopy(child_value)

package/server/services/credentials/__init__.py

@@ -0,0 +1,18 @@
+"""Credential-management WS handlers — Wave 13.5 extraction.
+
+Side-effect import registers the 4 credential CRUD handlers
+(validate_api_key / get_stored_api_key / save_api_key / delete_api_key)
+into ``ws_handler_registry``. The per-provider validation logic lives
+in ``services/plugin/credential.py``'s ``CREDENTIAL_REGISTRY``; these
+handlers just shape the request + response envelope around it.
+"""
+
+from __future__ import annotations
+
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers
+
+from .handlers import WS_HANDLERS as _CREDENTIALS_WS_HANDLERS
+
+_register_ws_handlers(_CREDENTIALS_WS_HANDLERS)
+
+__all__ = ["handlers"]