micro-cc 0.2.78__tar.gz → 0.2.79__tar.gz

micro_cc-0.2.79/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 George Salapa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{micro_cc-0.2.78/src/micro_cc.egg-info → micro_cc-0.2.79}/PKG-INFO

@@ -1,28 +1,31 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.78
+Version: 0.2.79
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
-License: Copyright (c) 2026 George Salapa. All rights reserved.
+License: MIT License
         
-        This software and associated source code ("Software") are proprietary and
-        confidential. No license, express or implied, is granted to any person
-        obtaining a copy of the Software.
+        Copyright (c) 2026 George Salapa
         
-        Permission to install and run the Software via its published package
-        (e.g. from PyPI) for personal or internal business use is granted, provided
-        that this permission does not extend to copying, modifying, merging,
-        publishing, distributing, sublicensing, forking, decompiling, reverse
-        engineering, or creating derivative works of the Software, in whole or in
-        part, without prior written permission from the copyright holder.
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
         
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR
-        OTHER LIABILITY ARISING FROM THE USE OF THE SOFTWARE.
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
         
-        Interested in collaborating? george@salapa.xyz
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
         
-Classifier: License :: Other/Proprietary License
+Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -197,4 +200,4 @@ Relative paths resolve to `project_dir`. Absolute paths work anywhere.
 
 ## License
 
-Proprietary — all rights reserved.
+MIT — see [LICENSE](LICENSE).

{micro_cc-0.2.78 → micro_cc-0.2.79}/README.md

@@ -133,4 +133,4 @@ Relative paths resolve to `project_dir`. Absolute paths work anywhere.
 
 ## License
 
-Proprietary — all rights reserved.
+MIT — see [LICENSE](LICENSE).

{micro_cc-0.2.78 → micro_cc-0.2.79}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.78"
+version = "0.2.79"
 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"
 license = {file = "LICENSE"}
 authors = [{name = "George Salapa"}]
-classifiers = ["License :: Other/Proprietary License"]
+classifiers = ["License :: OSI Approved :: MIT License"]
 
 dependencies = [
     "anthropic>=0.76.0",

{micro_cc-0.2.78 → micro_cc-0.2.79}/src/micro_cc/browser/_md_convert.py

@@ -24,7 +24,8 @@ import os
 import re
 
 
-from micro_cc.utils.helpers import get_endpoint
+from micro_cc.models import model_call
+from micro_cc.utils import settings_store_
 
 
 class _CustomMarkdownify(markdownify.MarkdownConverter):
@@ -639,26 +640,18 @@ class ImageConverter(MediaConverter):
     def _get_image_description(self, local_path, extension):
         prompt = "Write a detailed caption for this image."
 
-        data_uri = ""
         with open(local_path, "rb") as image_file:
-            content_type, encoding = mimetypes.guess_type("_dummy" + extension)
-            if content_type is None:
-                content_type = "image/jpeg"
             image_base64 = base64.b64encode(image_file.read()).decode("utf-8")
-            data_uri = f"data:{content_type};base64,{image_base64}"
-
-        endpoint = get_endpoint()
-        # Lazy-imported per-branch — see claude_loop_.py's dispatch for why.
-        if endpoint == "LiteLLM":
-            from micro_cc.models.litellm import l_model_call
-            response = asyncio.run(l_model_call(input=prompt, encoded_image=data_uri))
-        elif endpoint == "Foundry":
-            from micro_cc.models.foundry import f_model_call
-            response = asyncio.run(f_model_call(input=prompt, encoded_image=data_uri))
-        else:
-            from micro_cc.models.anthropic import a_model_call
-            response = asyncio.run(a_model_call(input=prompt, encoded_image=data_uri))
-        return response.content[0].text
+
+        # Providers add their own image envelope; encoded_image is bare base64.
+        # Use the selected model rather than a Claude default on OpenAI/Ollama.
+        response = asyncio.run(model_call(
+            input=prompt, encoded_image=image_base64,
+            model=settings_store_.get_setting("model"),
+        ))
+        if response is None:
+            return ""
+        return "\n".join(block.text for block in response.content if block.type == "text")
 
 
 class FileConversionException(BaseException):

{micro_cc-0.2.78 → micro_cc-0.2.79}/src/micro_cc/claude_loop_.py

@@ -1,6 +1,5 @@
 import asyncio
 import datetime
-import json
 import os
 from functools import partial
 
@@ -8,6 +7,7 @@ from dotenv import load_dotenv
 
 from micro_cc.cache.redis_cache import RedisStateManager
 from micro_cc.execute_tool import execute_tool_call
+from micro_cc.models import model_call
 from micro_cc.models.registry import DEFAULT_MODEL, DEFAULT_TRIM_BUDGET
 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
@@ -490,49 +490,14 @@ whole conversation history, including compacted turns.
         )
 
         try:
-            # Imported lazily, per-branch: anthropic/openai are the two
-            # heaviest imports in the whole app (pydantic building hundreds
-            # of response-type models — see search_tool_.py's own lazy
-            # AsyncOpenAI import for the same reason). Only one backend is
-            # ever active per session, so eagerly importing all four at
-            # module load (as this used to) paid for both SDKs on every
-            # startup no matter which endpoint was actually configured.
-            if end_resp == "Ollama":
-                from micro_cc.models.ollama import o_model_call
-                stream = await o_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            elif end_resp == "LiteLLM":
-                from micro_cc.models.litellm import l_model_call
-                stream = await l_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            elif end_resp == "Foundry":
-                from micro_cc.models.foundry import f_model_call
-                stream = await f_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
-            else:
-                from micro_cc.models.anthropic import a_model_call
-                stream = await a_model_call(
-                    input=trimmed_loop_msgs,
-                    model=model,
-                    tools=tool_schemas,
-                    thinking=True,
-                    stream=True,
-                )
+            stream = await model_call(
+                input=trimmed_loop_msgs,
+                model=model,
+                endpoint=end_resp,
+                tools=tool_schemas,
+                thinking=True,
+                stream=True,
+            )
 
             if stream is None:
                 yield {"type": "error", "message": "model call failed after retries"}
@@ -550,7 +515,15 @@ whole conversation history, including compacted turns.
                     api_usage = event.get("usage", {})
 
             if api_usage.get("input"):
+                # "input": last call's context size (live ctx% readout —
+                # same snapshot semantics as real Claude Code's
+                # calculateContextPercentages). "total_input": running sum
+                # across every call this session (same as real Claude
+                # Code's cost-tracker.ts addToTotalModelUsage) — each turn
+                # is its own billed API request, so real spend is this
+                # sum, not the size of the most recent one alone.
                 token_stats["input"] = api_usage["input"]
+                token_stats["total_input"] += api_usage["input"]
             if api_usage.get("output"):
                 token_stats["output"] += api_usage["output"]
             if api_usage:
@@ -870,14 +843,6 @@ whole conversation history, including compacted turns.
                 # for this whole turn (final_text/done) to finish.
                 yield {"type": "turn_boundary"}
 
-                # # Post-tool nudge (lightweight user reminder, not full context)
-                # plan_data_post = redis_state.get_plan(project_dir)
-                # if plan_data_post:
-                #     post_reminder = get_post_tool_plan_reminder(plan_data_post, all_blocks[0].name)
-                #     msgs.append({"role": "user", "content": f"<system-reminder>{post_reminder}</system-reminder>"})
-                # else:
-                #     msgs.append({"role": "user", "content": "<system-reminder>You just used a tool. Note what you found, then continue working silently — no narration needed.</system-reminder>"})
-
             # No tool use = final response (text already streamed as deltas)
             if not tool_use_blocks and text_block:
                 msgs.append({"role": "assistant", "content": text_block.text})

micro_cc-0.2.79/src/micro_cc/models/__init__.py

@@ -0,0 +1,6 @@
+"""Application model API. Provider SDKs are loaded only when called."""
+
+from micro_cc.models.client import model_call
+from micro_cc.models.types import ContentBlock, Response, ResponseStream, StreamEvent, Usage
+
+__all__ = ["model_call", "ContentBlock", "Response", "ResponseStream", "StreamEvent", "Usage"]

micro_cc-0.2.79/src/micro_cc/models/adapters/__init__.py

@@ -0,0 +1 @@
+"""SDK-output adapters. No credentials, requests, retries, or SDK imports here."""

micro_cc-0.2.79/src/micro_cc/models/adapters/anthropic.py

@@ -0,0 +1,91 @@
+"""Anthropic Messages output (direct API and Foundry)."""
+
+import json
+
+from micro_cc.models.types import ContentBlock, Response, ResponseStream
+
+
+def response(raw) -> Response:
+    """Normalize usage while retaining SDK content blocks and their extra fields.
+
+    Content blocks already implement the application's attribute interface;
+    keeping them also preserves signed/redacted thinking without a lossy copy.
+    """
+    usage = {}
+    u = getattr(raw, "usage", None)
+    if u:
+        usage = {
+            "input": (getattr(u, "input_tokens", 0)
+                      + getattr(u, "cache_read_input_tokens", 0)
+                      + getattr(u, "cache_creation_input_tokens", 0)),
+            "output": getattr(u, "output_tokens", 0),
+        }
+    return Response(content=raw.content, usage=usage)
+
+
+async def stream_response(raw_stream, unstealth=None) -> ResponseStream:
+    """Iterate Anthropic SDK stream, yield standardized deltas + final Response.
+
+    unstealth: optional str->str applied to each tool_use block's name —
+    supplied by the direct provider for OAuth tool-name mapping. Foundry
+    and API-key calls leave it unset."""
+    text = ""
+    thinking = ""
+    thinking_signature = ""
+    tool_blocks = []
+    current_tool = None
+    usage = {}
+
+    async for event in raw_stream:
+        if event.type == "message_start":
+            u = getattr(event.message, "usage", None)
+            if u:
+                # input_tokens alone is only the NEW (uncached) tokens for this
+                # turn — with the rolling cache breakpoint above, most of the
+                # transcript is cache_read/cache_creation instead, so input_tokens
+                # drops to near-zero after turn 1. The true context size sent to
+                # the API is the sum of all three.
+                usage["input"] = (
+                    getattr(u, "input_tokens", 0)
+                    + getattr(u, "cache_read_input_tokens", 0)
+                    + getattr(u, "cache_creation_input_tokens", 0)
+                )
+
+        elif event.type == "content_block_start":
+            if event.content_block.type == "tool_use":
+                current_tool = {"id": event.content_block.id, "name": event.content_block.name, "input_json": ""}
+
+        elif event.type == "content_block_delta":
+            if event.delta.type == "text_delta":
+                text += event.delta.text
+                yield {"type": "text_delta", "text": event.delta.text}
+            elif event.delta.type == "thinking_delta":
+                thinking += event.delta.thinking
+                yield {"type": "thinking_delta", "thinking": event.delta.thinking}
+            elif event.delta.type == "signature_delta":
+                thinking_signature += event.delta.signature or ""
+            elif event.delta.type == "input_json_delta":
+                if current_tool:
+                    current_tool["input_json"] += event.delta.partial_json
+
+        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})
+                current_tool = None
+
+        elif event.type == "message_delta":
+            u = getattr(event, "usage", None)
+            if u:
+                usage["output"] = getattr(u, "output_tokens", 0)
+
+    blocks = []
+    if thinking:
+        blocks.append(ContentBlock(type="thinking", thinking=thinking, signature=thinking_signature))
+    if text:
+        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"]))
+
+    yield {"type": "response", "response": Response(content=blocks, usage=usage), "usage": usage}

micro_cc-0.2.79/src/micro_cc/models/adapters/chat.py

@@ -0,0 +1,108 @@
+"""OpenAI Chat Completions output, including LiteLLM/Ollama reasoning.
+
+The wire protocol is shared; only reasoning extraction varies by provider.
+These functions consume streams in the caller's task without prefetch/retry.
+"""
+
+import json
+from typing import Literal
+
+from micro_cc.models.types import ContentBlock, Response, ResponseStream, Usage
+
+Reasoning = Literal["none", "litellm", "ollama"]
+
+
+def _reasoning_text(obj, reasoning: Reasoning) -> str:
+    if reasoning == "litellm":
+        return getattr(obj, "reasoning_content", None) or ""
+    if reasoning == "ollama":
+        text = getattr(obj, "reasoning", None)
+        if text:
+            return text
+        try:
+            return obj.model_dump().get("reasoning") or ""
+        except Exception:
+            return ""
+    return ""
+
+
+def _usage(raw) -> Usage:
+    u = getattr(raw, "usage", None)
+    if not u:
+        return {}
+    return {
+        "input": getattr(u, "prompt_tokens", 0),
+        "output": getattr(u, "completion_tokens", 0),
+    }
+
+
+def response(raw, *, reasoning: Reasoning = "none") -> Response:
+    """Normalize a completion, preserving LiteLLM's signed thinking block."""
+    msg = raw.choices[0].message
+    blocks = []
+    thinking_blocks = getattr(msg, "thinking_blocks", None) if reasoning == "litellm" else None
+    if thinking_blocks:
+        tb = thinking_blocks[0]
+        blocks.append(ContentBlock(
+            type="thinking",
+            thinking=tb.get("thinking", "") if isinstance(tb, dict) else getattr(tb, "thinking", ""),
+            signature=tb.get("signature", "") if isinstance(tb, dict) else getattr(tb, "signature", ""),
+        ))
+    else:
+        text = _reasoning_text(msg, reasoning)
+        if text:
+            blocks.append(ContentBlock(type="thinking", thinking=text))
+
+    if msg.content:
+        blocks.append(ContentBlock(type="text", text=msg.content))
+    for tc in msg.tool_calls or []:
+        try:
+            args = json.loads(tc.function.arguments)
+        except (json.JSONDecodeError, TypeError):
+            args = {}
+        blocks.append(ContentBlock(type="tool_use", name=tc.function.name, input=args, id=tc.id))
+    return Response(content=blocks, usage=_usage(raw))
+
+
+async def stream_response(raw_stream, *, reasoning: Reasoning = "none") -> ResponseStream:
+    """Yield deltas as received, then one response with assembled tool calls."""
+    text = ""
+    thinking = ""
+    tool_calls = {}  # index -> {id, name, args}; insertion order is call order
+    usage = {}
+
+    async for chunk in raw_stream:
+        # include_usage may produce a choices=[] trailer on any chat backend.
+        usage.update(_usage(chunk))
+        if not chunk.choices:
+            continue
+        delta = chunk.choices[0].delta
+        if delta.content:
+            text += delta.content
+            yield {"type": "text_delta", "text": delta.content}
+        rc = _reasoning_text(delta, reasoning)
+        if rc:
+            thinking += rc
+            yield {"type": "thinking_delta", "thinking": rc}
+        for tc in delta.tool_calls or []:
+            if tc.index not in tool_calls:
+                tool_calls[tc.index] = {
+                    "id": tc.id or "",
+                    "name": tc.function.name if tc.function else "",
+                    "args": "",
+                }
+            if tc.function and tc.function.arguments:
+                tool_calls[tc.index]["args"] += tc.function.arguments
+
+    blocks = []
+    if thinking:
+        blocks.append(ContentBlock(type="thinking", thinking=thinking))
+    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"]))
+    result = Response(content=blocks, usage=usage)
+    yield {"type": "response", "response": result, "usage": usage}

micro_cc-0.2.79/src/micro_cc/models/adapters/responses.py

@@ -0,0 +1,74 @@
+"""OpenAI Responses output (direct API and LiteLLM)."""
+
+import json
+
+from micro_cc.models.types import ContentBlock, Response, ResponseStream
+
+
+def response(resp) -> Response:
+    """Normalize a Responses API result, including non-stream usage."""
+    blocks = []
+    for item in resp.output:
+        if item.type == "reasoning":
+            summary = getattr(item, "summary", None) or []
+            text = "\n".join(getattr(s, "text", "") for s in summary)
+            if text:
+                blocks.append(ContentBlock(type="thinking", thinking=text))
+        elif item.type == "message":
+            for part in item.content:
+                if getattr(part, "type", None) == "output_text":
+                    blocks.append(ContentBlock(type="text", text=part.text))
+        elif item.type == "function_call":
+            try:
+                args = json.loads(item.arguments)
+            except (json.JSONDecodeError, TypeError):
+                args = {}
+            blocks.append(ContentBlock(
+                type="tool_use", name=item.name, input=args, id=item.call_id,
+            ))
+
+    usage = {}
+    u = getattr(resp, "usage", None)
+    if u:
+        usage["input"] = getattr(u, "input_tokens", 0)
+        usage["output"] = getattr(u, "output_tokens", 0)
+    return Response(content=blocks, usage=usage)
+
+
+async def stream_response(resp_stream) -> ResponseStream:
+    """Accumulate Responses API stream events, yield Anthropic-shaped
+    events, return final Response with ContentBlocks."""
+    text = ""
+    thinking = ""
+    tool_calls = []
+    usage = {}
+
+    async for ev in resp_stream:
+        et = ev.type
+        if et == "response.output_text.delta":
+            text += ev.delta
+            yield {"type": "text_delta", "text": ev.delta}
+        elif et == "response.reasoning_summary_text.delta":
+            thinking += ev.delta
+            yield {"type": "thinking_delta", "thinking": ev.delta}
+        elif et == "response.output_item.done" and getattr(ev.item, "type", None) == "function_call":
+            tool_calls.append(ev.item)
+        elif et == "response.completed":
+            u = ev.response.usage
+            if u:
+                usage["input"] = getattr(u, "input_tokens", 0)
+                usage["output"] = getattr(u, "output_tokens", 0)
+
+    blocks = []
+    if thinking:
+        blocks.append(ContentBlock(type="thinking", thinking=thinking))
+    if text:
+        blocks.append(ContentBlock(type="text", text=text))
+    for tc in tool_calls:
+        try:
+            args = json.loads(tc.arguments)
+        except (json.JSONDecodeError, TypeError):
+            args = {}
+        blocks.append(ContentBlock(type="tool_use", name=tc.name, input=args, id=tc.call_id))
+
+    yield {"type": "response", "response": Response(content=blocks, usage=usage), "usage": usage}