micro-cc 0.2.83__tar.gz → 0.2.85__tar.gz

{micro_cc-0.2.83/src/micro_cc.egg-info → micro_cc-0.2.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.83
+Version: 0.2.85
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License: MIT License

{micro_cc-0.2.83 → micro_cc-0.2.85}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.83"
+version = "0.2.85"
 description = "Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -51,7 +51,13 @@ dependencies = [
 postgres = ["psycopg[binary]>=3.2"]
 
 [project.scripts]
-microcc = "micro_cc.start_live_tui_:start_"
+# The interactive entry point goes through the supervisor (self_heal_.main),
+# not start_live_tui_ directly: the harness is plain source the model can edit,
+# so a bad self-edit can stop the app booting — and the only process that could
+# report that is the one that won't start. self_heal_ catches a boot failure,
+# reinstalls the published wheel over the broken tree and retries, bounded.
+# headless stays direct — it's a one-shot run, not a long-lived UI to supervise.
+microcc = "micro_cc.self_heal_:main"
 microcc-headless = "micro_cc.start_headless_:start_headless_"
 
 [tool.setuptools.packages.find]

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/claude_loop_.py

@@ -13,10 +13,8 @@ from micro_cc.utils.tool_limits import cap_for, MAX_TOOL_RESULTS_PER_MESSAGE
 from micro_cc.utils.tool_result_storage import persist_and_preview
 from micro_cc.models.schema import function_to_schema
 from micro_cc.skills.skill_loader import get_skill_summary
-from micro_cc.tools.bash_tool import bash_, list_background_processes
+from micro_cc.tools.bash_tool import bash_
 from micro_cc.tools.monitor_ import monitor_
-from micro_cc.tools.monitor_watch_ import list_watches as list_monitor_watches
-from micro_cc.utils import subagent_tracker_
 from micro_cc.tools.file_tools_ import read_, write_, edit_, glob_, grep_
 from micro_cc.tools.search_tool_ import search_tools, list_mcps
 from micro_cc.tools.todo_tools_ import todo_tool_
@@ -145,25 +143,20 @@ async def claude_loop(
         search_history_,
         read_skill, list_skills, list_mcps,
         ask_user_question_tool_,
+        monitor_,
     ]
-    # monitor_ is conditional, not a permanent fixture here: it's only worth
-    # a schema slot on a turn where there's actually something to monitor —
-    # a tracked subagent, a bash_-backgrounded process still alive, or an
-    # already-running monitor_(action="watch") stream. All three are cheap
-    # (in-memory dict lookups, one small JSON file read — no network, no
-    # subprocess), so checking every turn costs nothing on the common case
-    # where none of them apply and monitor_ simply doesn't appear. This is
-    # deliberately NOT the search_tools discoverable path (see
-    # search_tool_.py's comment by monitor_'s old registration there) —
-    # the model would have to think to search for it, and either there's
-    # nothing to monitor (in which case the tool would be a no-op anyway)
-    # or one of the checks below already put it in scope.
-    if (
-        list_background_processes()
-        or subagent_tracker_.read_tracked(project_dir)["subagents"]
-        or list_monitor_watches()
-    ):
-        default_tools.append(monitor_)
+    # monitor_ is a PERMANENT core tool (like memory_), not conditionally
+    # injected. It used to appear only when something already existed to
+    # monitor — a tracked subagent, a live backgrounded process, an active
+    # watch — but that made its create-style actions unreachable on a fresh
+    # session: you cannot schedule "wake me in 20 minutes" (action="schedule"),
+    # start a watch (action="watch"), or set anything up if the tool isn't in
+    # scope precisely *because* nothing exists yet. Same reasoning as memory_:
+    # a tool whose job is to CREATE things has to be reachable when there's
+    # nothing. The read actions ("check"/"list"/"schedules") self-report empty,
+    # so an always-present monitor_ costs one schema slot and nothing else.
+    # Its own docstring is the discovery surface; no search_tools registration
+    # needed (see search_tool_.py's comment by monitor_'s old registration).
     tool_schemas = []
     for tool in default_tools:
         tool_schemas.append(function_to_schema(tool))
@@ -570,11 +563,24 @@ whole conversation history, including compacted turns.
                             for failure in new_mcp_failures:
                                 yield {"type": "error", "message": failure}
 
+                # A tool_use block whose streamed arguments didn't parse as
+                # JSON (adapter sets ContentBlock.parse_error rather than
+                # raising or inventing {} args — see models/adapters/*.py)
+                # must never execute with wrong/empty input. Excluded from
+                # local/mcp below and handled the same way as an unknown
+                # tool name: an is_error tool_result telling the model what
+                # broke, so it can retry, instead of the exception
+                # propagating out of the stream and killing the whole turn.
+                malformed_by_id = {tb.id: tb.parse_error for tb in tool_use_blocks if tb.parse_error}
+
                 # Split into: local tools, client-side MCP tools, truly unknown
-                local_tool_blocks = [tb for tb in tool_use_blocks if tb.name in tools]
-                mcp_tool_blocks = [tb for tb in tool_use_blocks if tb.name in mcp_routing]
+                local_tool_blocks = [tb for tb in tool_use_blocks
+                                     if tb.name in tools and tb.id not in malformed_by_id]
+                mcp_tool_blocks = [tb for tb in tool_use_blocks
+                                   if tb.name in mcp_routing and tb.id not in malformed_by_id]
                 unknown_blocks = [tb for tb in tool_use_blocks
-                                  if tb.name not in tools and tb.name not in mcp_routing]
+                                  if tb.name not in tools and tb.name not in mcp_routing
+                                  and tb.id not in malformed_by_id]
 
                 # Hallucinated tool names get an error tool_result instead of
                 # being executed — folded into the single turn message below
@@ -716,6 +722,20 @@ whole conversation history, including compacted turns.
                 tool_result_blocks = []
                 persisted_this_turn = set()
                 for tool_block in tool_use_blocks:
+                    if tool_block.id in malformed_by_id:
+                        tool_result_blocks.append(
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": tool_block.id,
+                                "content": (
+                                    f"Error: arguments for tool '{tool_block.name}' were not valid JSON "
+                                    f"({malformed_by_id[tool_block.id]}). Retry the call with valid JSON input."
+                                ),
+                                "is_error": True,
+                            }
+                        )
+                        continue
+
                     if tool_block.id in unknown_ids:
                         tool_result_blocks.append(
                             {
@@ -854,7 +874,8 @@ whole conversation history, including compacted turns.
                             break
                         block = tool_result_blocks[i]
                         tb = by_id.get(block["tool_use_id"])
-                        if tb is None or tb.id in persisted_this_turn or tb.id in unknown_ids or tb.id in ask_errors_by_id:
+                        if (tb is None or tb.id in persisted_this_turn or tb.id in unknown_ids
+                                or tb.id in ask_errors_by_id or tb.id in malformed_by_id):
                             continue
                         old_len = len(block["content"])
                         block["content"] = persist_and_preview(

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/adapters/anthropic.py

@@ -74,8 +74,21 @@ async def stream_response(raw_stream, unstealth=None) -> ResponseStream:
 
         elif event.type == "content_block_stop":
             if current_tool:
-                args = json.loads(current_tool["input_json"]) if current_tool["input_json"] else {}
-                tool_blocks.append(current_tool | {"input": args})
+                parse_error = ""
+                try:
+                    args = json.loads(current_tool["input_json"]) if current_tool["input_json"] else {}
+                except json.JSONDecodeError as e:
+                    # Never invent arguments for a tool call whose streamed
+                    # JSON didn't parse — but don't let this raise either:
+                    # that used to propagate out of the whole generator and
+                    # take down the entire turn (claude_loop_'s outer
+                    # except-and-break) over one bad tool call. Flagging it
+                    # on the block instead lets claude_loop_ hand the model
+                    # an is_error tool_result and continue, same treatment
+                    # as a hallucinated tool name.
+                    args = {}
+                    parse_error = str(e)
+                tool_blocks.append(current_tool | {"input": args, "parse_error": parse_error})
                 current_tool = None
 
         elif event.type == "message_delta":
@@ -90,6 +103,9 @@ async def stream_response(raw_stream, unstealth=None) -> ResponseStream:
         blocks.append(ContentBlock(type="text", text=text))
     for tb in tool_blocks:
         name = unstealth(tb["name"]) if unstealth else tb["name"]
-        blocks.append(ContentBlock(type="tool_use", name=name, input=tb["input"], id=tb["id"]))
+        blocks.append(ContentBlock(
+            type="tool_use", name=name, input=tb["input"], id=tb["id"],
+            parse_error=tb.get("parse_error", ""),
+        ))
 
     yield {"type": "response", "response": Response(content=blocks, usage=usage), "usage": usage}

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/adapters/chat.py

@@ -1,4 +1,4 @@
-"""OpenAI Chat Completions output, including LiteLLM/Ollama reasoning.
+"""OpenAI Chat Completions output, including LiteLLM/Ollama/OpenRouter reasoning.
 
 The wire protocol is shared; only reasoning extraction varies by provider.
 These functions consume streams in the caller's task without prefetch/retry.
@@ -9,13 +9,14 @@ from typing import Literal
 
 from micro_cc.models.types import ContentBlock, Response, ResponseStream, Usage
 
-Reasoning = Literal["none", "litellm", "ollama"]
+Reasoning = Literal["none", "litellm", "ollama", "openrouter"]
 
 
 def _reasoning_text(obj, reasoning: Reasoning) -> str:
     if reasoning == "litellm":
         return getattr(obj, "reasoning_content", None) or ""
-    if reasoning == "ollama":
+    if reasoning in ("ollama", "openrouter"):
+        # Same plain "reasoning" string field on both.
         text = getattr(obj, "reasoning", None)
         if text:
             return text
@@ -56,11 +57,15 @@ def response(raw, *, reasoning: Reasoning = "none") -> Response:
     if msg.content:
         blocks.append(ContentBlock(type="text", text=msg.content))
     for tc in msg.tool_calls or []:
+        parse_error = ""
         try:
             args = json.loads(tc.function.arguments)
-        except (json.JSONDecodeError, TypeError):
+        except (json.JSONDecodeError, TypeError) as e:
             args = {}
-        blocks.append(ContentBlock(type="tool_use", name=tc.function.name, input=args, id=tc.id))
+            parse_error = str(e)
+        blocks.append(ContentBlock(
+            type="tool_use", name=tc.function.name, input=args, id=tc.id, parse_error=parse_error,
+        ))
     return Response(content=blocks, usage=_usage(raw))
 
 
@@ -100,9 +105,22 @@ async def stream_response(raw_stream, *, reasoning: Reasoning = "none") -> Respo
     if text:
         blocks.append(ContentBlock(type="text", text=text))
     for tc in tool_calls.values():
-        # As before, malformed streamed arguments fail rather than execute a
-        # partial call with invented arguments. No retry after visible deltas.
-        args = json.loads(tc["args"]) if tc["args"] else {}
-        blocks.append(ContentBlock(type="tool_use", name=tc["name"], input=args, id=tc["id"]))
+        # Malformed streamed arguments never execute as a partial call with
+        # invented input — but parse failure is flagged on the block
+        # (parse_error) rather than raised: raising here used to propagate
+        # out of this whole generator and kill the entire turn (claude_loop_'s
+        # outer except-and-break) over one bad tool call. claude_loop_ instead
+        # hands the model an is_error tool_result and continues, same
+        # treatment as a hallucinated tool name.
+        parse_error = ""
+        args = {}
+        if tc["args"]:
+            try:
+                args = json.loads(tc["args"])
+            except json.JSONDecodeError as e:
+                parse_error = str(e)
+        blocks.append(ContentBlock(
+            type="tool_use", name=tc["name"], input=args, id=tc["id"], parse_error=parse_error,
+        ))
     result = Response(content=blocks, usage=usage)
     yield {"type": "response", "response": result, "usage": usage}

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/adapters/responses.py

@@ -19,12 +19,14 @@ def response(resp) -> Response:
                 if getattr(part, "type", None) == "output_text":
                     blocks.append(ContentBlock(type="text", text=part.text))
         elif item.type == "function_call":
+            parse_error = ""
             try:
                 args = json.loads(item.arguments)
-            except (json.JSONDecodeError, TypeError):
+            except (json.JSONDecodeError, TypeError) as e:
                 args = {}
+                parse_error = str(e)
             blocks.append(ContentBlock(
-                type="tool_use", name=item.name, input=args, id=item.call_id,
+                type="tool_use", name=item.name, input=args, id=item.call_id, parse_error=parse_error,
             ))
 
     usage = {}
@@ -65,10 +67,14 @@ async def stream_response(resp_stream) -> ResponseStream:
     if text:
         blocks.append(ContentBlock(type="text", text=text))
     for tc in tool_calls:
+        parse_error = ""
         try:
             args = json.loads(tc.arguments)
-        except (json.JSONDecodeError, TypeError):
+        except (json.JSONDecodeError, TypeError) as e:
             args = {}
-        blocks.append(ContentBlock(type="tool_use", name=tc.name, input=args, id=tc.call_id))
+            parse_error = str(e)
+        blocks.append(ContentBlock(
+            type="tool_use", name=tc.name, input=args, id=tc.call_id, parse_error=parse_error,
+        ))
 
     yield {"type": "response", "response": Response(content=blocks, usage=usage), "usage": usage}

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/client.py

@@ -10,6 +10,7 @@ _PROVIDERS = {
     "Foundry": ("foundry", "f_model_call"),
     "LiteLLM": ("litellm", "l_model_call"),
     "OpenAI": ("openai", "oai_model_call"),
+    "OpenRouter": ("openrouter", "or_model_call"),
     "Ollama": ("ollama", "o_model_call"),
 }
 

micro_cc-0.2.85/src/micro_cc/models/openrouter.py

@@ -0,0 +1,248 @@
+"""OpenRouter requests via its OpenAI-compatible endpoint.
+
+No fixed alias table (models/registry.py) — the model is whatever
+"author/slug" the user pasted at /login. resolve() still runs but just
+passes it through unchanged. Reasoning uses OpenRouter's unified `reasoning`
+param instead of a provider-specific toggle.
+
+Env vars:
+    OPENROUTER_API_KEY:  API key (openrouter.ai/keys)
+    OPENROUTER_BASE_URL: default https://openrouter.ai/api/v1
+"""
+
+from typing import List, Dict, Any, Optional, Union
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+import asyncio
+import json
+import os
+
+from micro_cc.models.adapters import chat
+from micro_cc.models.priming import prime_stream
+from micro_cc.models.schema import tools_to_chat
+from micro_cc.models.registry import DEFAULT_MODEL, resolve, supports_thinking
+
+load_dotenv(os.path.expanduser("~/.micro-cc/.env"))
+load_dotenv()
+
+FIRST_EVENT_TIMEOUT = 60
+
+
+# ---------------------------------------------------------------------------
+# Converters — Anthropic format -> OpenAI chat format
+# ---------------------------------------------------------------------------
+
+
+def _msgs_to_openai(anthropic_msgs):
+    """Anthropic-format message list -> OpenAI chat format. Thinking blocks
+    are dropped — the model re-derives reasoning each turn instead."""
+    out = []
+    for msg in anthropic_msgs:
+        role = msg.get("role")
+        content = msg.get("content", "")
+
+        if role == "system":
+            out.append({"role": "system", "content": content})
+            continue
+
+        if role == "assistant" and isinstance(content, list):
+            text_parts = []
+            tool_calls = []
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get("type")
+                if btype == "text":
+                    text_parts.append(block["text"])
+                elif btype == "tool_use":
+                    tool_calls.append({
+                        "id": block["id"],
+                        "type": "function",
+                        "function": {
+                            "name": block["name"],
+                            "arguments": json.dumps(block["input"]),
+                        },
+                    })
+
+            m = {
+                "role": "assistant",
+                "content": "\n".join(text_parts) if text_parts else None,
+            }
+            if tool_calls:
+                m["tool_calls"] = tool_calls
+            out.append(m)
+            continue
+
+        if role == "user" and isinstance(content, list):
+            tool_results = []
+            other_parts = []
+
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get("type")
+                if btype == "tool_result":
+                    tr_content = block.get("content", "")
+                    if isinstance(tr_content, list):
+                        tool_results.append({
+                            "role": "tool",
+                            "tool_call_id": block["tool_use_id"],
+                            "content": "[image attached — see following message]",
+                        })
+                        for item in tr_content:
+                            if item.get("type") == "image":
+                                source = item.get("source", {})
+                                media = source.get("media_type", "image/jpeg")
+                                other_parts.append({
+                                    "type": "image_url",
+                                    "image_url": {"url": f"data:{media};base64,{source.get('data', '')}"},
+                                })
+                    else:
+                        tool_results.append({
+                            "role": "tool",
+                            "tool_call_id": block["tool_use_id"],
+                            "content": tr_content,
+                        })
+                elif btype == "text":
+                    other_parts.append({"type": "text", "text": block["text"]})
+                elif btype == "image":
+                    source = block.get("source", {})
+                    media = source.get("media_type", "image/jpeg")
+                    other_parts.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:{media};base64,{source.get('data', '')}",
+                        },
+                    })
+                elif btype == "document":
+                    other_parts.append({
+                        "type": "text",
+                        "text": "[PDF document attached]",
+                    })
+
+            out.extend(tool_results)
+
+            if other_parts:
+                if len(other_parts) == 1 and other_parts[0].get("type") == "text":
+                    out.append({"role": "user", "content": other_parts[0]["text"]})
+                else:
+                    out.append({"role": "user", "content": other_parts})
+            continue
+
+        out.append({"role": role, "content": content})
+
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Main entry point — same signature pattern as models/ollama.py
+# ---------------------------------------------------------------------------
+
+
+async def or_model_call(
+    input: Union[List[Dict[str, Any]], str],
+    model=DEFAULT_MODEL,
+    encoded_image: Optional[Union[str, List[str]]] = None,
+    tools: Optional[List[Dict[str, Any]]] = None,
+    stream: bool = False,
+    thinking: bool = False,
+    max_tokens: int = 120000,
+    client_timeout: int = 480,
+    pdf: str = None,
+    retries: int = 3,
+):
+    base_url = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
+    client = AsyncOpenAI(
+        base_url=base_url,
+        api_key=os.getenv("OPENROUTER_API_KEY", ""),
+        timeout=client_timeout,
+    )
+    base_sleep = 2
+
+    alias = model
+    model = resolve(alias, "openrouter")
+
+    # ---- Build messages ----
+    if pdf:
+        messages = [{"role": "user", "content": f"[PDF document attached]\n\n{input}"}]
+    elif encoded_image:
+        content = []
+        imgs = [encoded_image] if isinstance(encoded_image, str) else encoded_image
+        for img in imgs:
+            content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{img}"},
+            })
+        content.append({"type": "text", "text": input})
+        messages = [{"role": "user", "content": content}]
+    elif isinstance(input, str):
+        messages = [{"role": "user", "content": input}]
+    else:
+        messages = _msgs_to_openai(input)
+
+    # ---- API parameters ----
+    api_params = {
+        "model": model,
+        "max_tokens": max_tokens,
+        "stream": stream,
+        "messages": messages,
+    }
+
+    if stream:
+        api_params["stream_options"] = {"include_usage": True}
+
+    # Non-standard params (vLLM/HF-ecosystem, not part of OpenAI's own API
+    # surface) must ride in extra_body — the openai SDK's typed
+    # chat.completions.create() raises a TypeError on an unknown top-level
+    # kwarg before a request is even sent, it doesn't pass it through.
+    extra_body = {}
+
+    if thinking and supports_thinking(alias):
+        # OpenRouter's unified reasoning param — a no-op on unsupported models.
+        extra_body["reasoning"] = {"effort": "high"}
+
+    # Sampling-level guard against the literal token-repetition loop some
+    # open-weight reasoning models (DeepSeek in particular) fall into under
+    # sustained deliberation — short tokens ("Go." / "OK." / "Write.")
+    # cycling instead of terminating. repetition_penalty is the
+    # provider-native lever for exactly this failure mode (>1.0 penalizes
+    # tokens already seen in the generation so far). A model that doesn't
+    # support it (not in its OpenRouter supported_parameters) just ignores
+    # the field rather than erroring. 1.1 is a conservative default — tune
+    # here if retesting shows it's too weak/strong.
+    extra_body["repetition_penalty"] = 1.1
+
+    if extra_body:
+        api_params["extra_body"] = extra_body
+
+    if tools:
+        openrouter_tools = tools_to_chat(tools)
+        if openrouter_tools:
+            api_params["tools"] = openrouter_tools
+            api_params["tool_choice"] = "auto"
+
+    # ---- Call with retries ----
+    for attempt in range(retries):
+        try:
+            response = await client.chat.completions.create(**api_params)
+            if stream:
+                return await prime_stream(
+                    chat.stream_response(response, reasoning="openrouter"), FIRST_EVENT_TIMEOUT
+                )
+            else:
+                return chat.response(response, reasoning="openrouter")
+
+        except Exception as e:
+            import traceback
+            print(f"\n[openrouter model_call]: {e}", flush=True)
+            traceback.print_exc()
+            if attempt < retries - 1:
+                sleep_time = base_sleep * (2 ** attempt)
+                print(
+                    f"\n[openrouter model_call]: Retrying in {sleep_time}s (attempt {attempt + 1}/{retries})..."
+                )
+                await asyncio.sleep(sleep_time)
+            else:
+                print(f"\n[openrouter model_call]: Failed after {retries} attempts")
+
+    return None

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/registry.py

@@ -89,18 +89,23 @@ DEFAULT_TRIM_BUDGET = 100_000
 # for output (max_output, where known).
 PROMPT_RESERVE = 20_000
 
+# Per-backend fallback for trim_budget_for when `alias` isn't in MODELS —
+# OpenRouter aliases are free-text (never registered), so this is what they
+# always get instead of the conservative DEFAULT_TRIM_BUDGET. Ollama isn't
+# here: it derives its own budget from OLLAMA_NUM_CTX (start_live_tui_.py's
+# _ollama_trim_budget) and never calls this function.
+BACKEND_DEFAULT_TRIM_BUDGET = {
+    "openrouter": 1_000_000,
+}
 
-def trim_budget_for(alias: str) -> int:
-    """Per-model transcript trim budget: context_window - max_output -
-    PROMPT_RESERVE, floored at DEFAULT_TRIM_BUDGET so an alias with no
-    context_window entry (unregistered, or an Ollama model — those are
-    sized from OLLAMA_NUM_CTX instead, see start_live_._ollama_trim_budget)
-    doesn't get starved down to something smaller than the old flat default.
-    """
+
+def trim_budget_for(alias: str, backend: str | None = None) -> int:
+    """Per-model trim budget: context_window - max_output - PROMPT_RESERVE,
+    floored at DEFAULT_TRIM_BUDGET or BACKEND_DEFAULT_TRIM_BUDGET[backend]."""
     entry = MODELS.get(alias)
     window = entry.get("context_window") if entry else None
     if not window:
-        return DEFAULT_TRIM_BUDGET
+        return BACKEND_DEFAULT_TRIM_BUDGET.get(backend, DEFAULT_TRIM_BUDGET)
     max_output = entry.get("max_output", 0) if entry else 0
     return max(DEFAULT_TRIM_BUDGET, window - max_output - PROMPT_RESERVE)
 

{micro_cc-0.2.83 → micro_cc-0.2.85}/src/micro_cc/models/types.py

@@ -19,6 +19,13 @@ class ContentBlock:
     name: str = ""
     input: dict = field(default_factory=dict)
     id: str = ""
+    # Set (to the JSONDecodeError message) when a tool_use block's streamed
+    # arguments didn't parse as JSON. `input` is left {} rather than the
+    # model's raw, invented-looking partial text — but the block still
+    # carries id/name so claude_loop_ can pair it with an is_error
+    # tool_result instead of dropping it and violating the API's "one
+    # tool_result per tool_use" contract.
+    parse_error: str = ""
 
 
 class Usage(TypedDict, total=False):