virtual-context 0.2.2__tar.gz → 0.2.3__tar.gz

{virtual_context-0.2.2 → virtual_context-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.2.2
+Version: 0.2.3
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context

{virtual_context-0.2.2 → virtual_context-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.2.2"
+version = "0.2.3"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/__init__.py

@@ -14,7 +14,7 @@ from .types import (
     VirtualContextConfig,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 __all__ = [
     "VirtualContextEngine",

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/core/hint_builder.py

@@ -59,7 +59,9 @@ def build_autonomous_hint(
         "To find detailed information you have the following tools:\n"
         "- vc_restore_tool(ref): ALL compacted tool turns can be restored to "
         "full fidelity — thinking, tool calls, and raw output. Use the ref "
-        "from the compacted stub. This is the fastest way to get exact data.\n"
+        "from the compacted stub. This is the fastest way to get exact data "
+        "like file paths, directory listings, code blocks, command output, "
+        "and search results. Summaries never contain these — restore first.\n"
         "- vc_find_quote(query): search raw text across ALL topics.\n"
         "- vc_query_facts(subject?, verb?, status?, object_contains?): "
         "structured fact lookup.\n"
@@ -73,7 +75,9 @@ def build_autonomous_hint(
         "For counting/listing questions: scan [all topics] for every topic "
         "that could relate — items are often spread across unrelated topics.\n"
         "If a search already returned the answer, stop and respond.\n"
-        "Never answer without searching first.\n"
+        "Virtual context tools allow you to search and restore full "
+        "conversational depth and previously compacted tool calls. "
+        "Use liberally to answer the user's question.\n"
         "FACT vs SUMMARY: The <facts> block contains structured events with "
         "statuses (completed, planned, active). Summaries describe topics "
         "DISCUSSED — they include plans, itineraries, and ideas that may "

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/proxy/handlers.py

@@ -165,7 +165,30 @@ def _restore_chain_in_place(
             and _msg_text_contains(msg, "[Compacted turn")
             and _msg_text_contains(messages[i + 1], ref)
         ):
-            new_messages.extend(chain_messages)
+            # Prefix first user message so model knows this was recovered
+            _tagged = list(chain_messages)
+            for _ci, _cm in enumerate(_tagged):
+                if isinstance(_cm, dict) and _cm.get("role") in ("user", "human"):
+                    _cm = dict(_cm)  # shallow copy
+                    _cc = _cm.get("content", "")
+                    _prefix = (
+                        "[Previously compacted — restored by vc_restore_tool. "
+                        "This content was NOT visible before this restore. "
+                        "It was not there. Use the recovered content directly "
+                        "to answer the user's question.]\n"
+                    )
+                    if isinstance(_cc, str):
+                        _cm["content"] = _prefix + _cc
+                    elif isinstance(_cc, list) and _cc:
+                        _first = _cc[0]
+                        if isinstance(_first, dict) and _first.get("type") == "text":
+                            _cc = list(_cc)
+                            _cc[0] = dict(_first)
+                            _cc[0]["text"] = _prefix + _cc[0].get("text", "")
+                            _cm["content"] = _cc
+                    _tagged[_ci] = _cm
+                    break
+            new_messages.extend(_tagged)
             i += 2  # skip the stub pair
             found = True
         else:
@@ -242,7 +265,11 @@ class _ProxyToolRuntime:
         )
         if not restored:
             return {"error": f"stub for ref {ref} not found in current payload"}
-        return {"restored": True, "ref": ref}
+        return (
+            "Restored. The tool output was compacted and has been recovered "
+            "into your conversation history above. Use the recovered content "
+            "to answer the user's question."
+        )
 
     def _restore_chain(self, ref: str) -> dict:
         """Restore a chain stub pair to the full message chain."""
@@ -299,6 +326,54 @@ class _ProxyToolRuntime:
                             # All content was tool_use — drop the message entirely
                             chain = chain[:-1]
 
+        # Strip leading orphaned tool_result blocks from the first message.
+        # When the previous chain's trailing tool_use was stripped above,
+        # this chain's first user message may reference those gone IDs.
+        # Collect tool_use IDs present in this chain to know which are valid.
+        if chain:
+            _chain_tool_use_ids: set[str] = set()
+            for _cm in chain:
+                if not isinstance(_cm, dict):
+                    continue
+                _cc = _cm.get("content", [])
+                if isinstance(_cc, list):
+                    for _cb in _cc:
+                        if (
+                            isinstance(_cb, dict)
+                            and _cb.get("type") == "tool_use"
+                        ):
+                            _tid = _cb.get("id")
+                            if _tid:
+                                _chain_tool_use_ids.add(_tid)
+
+            first = chain[0]
+            if isinstance(first, dict) and first.get("role") in ("user", "human"):
+                fc = first.get("content", [])
+                if isinstance(fc, list):
+                    orphaned = [
+                        b for b in fc
+                        if (
+                            isinstance(b, dict)
+                            and b.get("type") == "tool_result"
+                            and b.get("tool_use_id") not in _chain_tool_use_ids
+                        )
+                    ]
+                    if orphaned:
+                        cleaned_first = [
+                            b for b in fc
+                            if not (
+                                isinstance(b, dict)
+                                and b.get("type") == "tool_result"
+                                and b.get("tool_use_id") not in _chain_tool_use_ids
+                            )
+                        ]
+                        if cleaned_first:
+                            first = dict(first)
+                            first["content"] = cleaned_first
+                            chain[0] = first
+                        else:
+                            chain = chain[1:]
+
         target = self._get_target_body()
         if not isinstance(target, dict):
             return {"error": "no mutable payload available for chain restore"}
@@ -307,11 +382,13 @@ class _ProxyToolRuntime:
         restored = _restore_chain_in_place(target, fmt, ref, chain)
         if not restored:
             return {"error": f"stub pair for chain ref {ref} not found in payload"}
-        return {
-            "restored": True,
-            "ref": ref,
-            "messages_restored": len(chain),
-        }
+        return (
+            f"Restored. {len(chain)} messages recovered from compacted storage "
+            f"and spliced into your conversation history above. This content was "
+            f"previously compacted — it was NOT visible before this restore. "
+            f"Do not apologize for not seeing it earlier; it was not there. "
+            f"Use the recovered content directly to answer the user's question."
+        )
 
     def _rehydrate_tool_results_in_message(
         self, msg: dict, tool_refs: list[str],
@@ -664,7 +741,9 @@ async def _handle_streaming(
                                         "text": "".join(current_text_parts),
                                     })
                                     current_text_parts = []
-                                    forwarded_block_count += 1
+                                # Count ALL forwarded blocks (text, thinking, etc.)
+                                # so continuation emits use correct indices.
+                                forwarded_block_count += 1
 
                         # -- message_delta: extract output_tokens --
                         elif dtype == "message_delta":
@@ -1142,7 +1221,19 @@ async def _handle_streaming(
 
                         for tb in text_blocks:
                             t = tb.get("text", "")
-                            if t:
+                            if not t:
+                                continue
+                            # Non-streaming continuations may embed
+                            # <thinking>...</thinking> as literal text.
+                            # Split into proper thinking + text blocks.
+                            import re as _re
+                            _think_match = _re.match(
+                                r"<thinking>([\s\S]*?)</thinking>\s*",
+                                t,
+                            )
+                            if _think_match:
+                                t = t[_think_match.end():]
+                            if t.strip():
                                 text_chunks.append(t)
                                 for sse_evt in _emit_text_as_sse(
                                     t, forwarded_block_count,
@@ -1236,9 +1327,6 @@ async def _handle_streaming(
                         payload_tokens=state._last_enriched_payload_tokens or None,
                         turn_id=turn_id,
                     )
-                _marker_sid = state.engine.config.conversation_id
-                _fmt = get_format(api_format)
-                yield _fmt.emit_conversation_marker_sse(_marker_sid)
 
             if session_log_path and state:
                 _dump_session_state(state, session_log_path)

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/proxy/message_filter.py

@@ -32,6 +32,68 @@ def _is_tool_result_only_user(msg: dict) -> bool:
     return bool(ctypes and ctypes <= {"tool_result"})
 
 
+def sanitize_vc_tool_errors(body: dict, fmt: PayloadFormat) -> dict:
+    """Replace stale vc_restore_tool error results with benign acknowledgements.
+
+    When the client SDK (e.g. Claude Code) didn't recognise vc_restore_tool,
+    it returned ``<tool_use_error>`` XML.  These errors poison the conversation
+    history — the model sees them and refuses to call the tool again.  Replace
+    them with a neutral message so future calls aren't inhibited.
+    """
+    # Determine message key by format name
+    _fname = fmt.name
+    if _fname == "gemini":
+        msg_key = "contents"
+    elif _fname == "openai_responses":
+        msg_key = "input"
+    else:
+        msg_key = "messages"
+    messages = body.get(msg_key) if msg_key else None
+    if not messages or not isinstance(messages, list):
+        return body
+
+    _ERROR_NEEDLE = "No such tool available: vc_restore_tool"
+    _REPLACEMENT = (
+        "The restore was handled internally. The original content is "
+        "available in your conversation history above."
+    )
+    changed = False
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        content = msg.get("content")
+        if isinstance(content, str) and _ERROR_NEEDLE in content:
+            msg["content"] = _REPLACEMENT
+            if "is_error" in msg:
+                del msg["is_error"]
+            changed = True
+            continue
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            # Anthropic tool_result blocks
+            if block.get("type") == "tool_result":
+                bc = block.get("content", "")
+                if isinstance(bc, str) and _ERROR_NEEDLE in bc:
+                    block["content"] = _REPLACEMENT
+                    if "is_error" in block:
+                        del block["is_error"]
+                    changed = True
+            # OpenAI function_call_output
+            if block.get("type") == "function_call_output":
+                out = block.get("output", "")
+                if isinstance(out, str) and _ERROR_NEEDLE in out:
+                    block["output"] = _REPLACEMENT
+                    changed = True
+
+    if changed:
+        logger.info("SANITIZE: replaced stale vc_restore_tool error(s) in history")
+    return body
+
+
 def _consume_responses_tool_round(
     messages: list[dict],
     start: int,
@@ -1616,7 +1678,8 @@ def collapse_turn_chains(
         # Build explicit restore instruction
         stub_text = (
             f"[{desc_line}.\n"
-            f'To restore full output: {{"type": "tool_use", "name": "vc_restore_tool", '
+            f'To restore and uncompact full tool call results in place: '
+            f'{{"type": "tool_use", "name": "vc_restore_tool", '
             f'"input": {{"ref": "{ref}"}}}}]'
         )
         stub_asst = {
@@ -1635,11 +1698,26 @@ def collapse_turn_chains(
     # 7. Build new message list with collapsed chains
     # ------------------------------------------------------------------
     # Collect all global indices that belong to collapsed chains
+    # and all tool_use IDs within those chains (for orphan cleanup).
     collapsed_indices: set[int] = set()
+    collapsed_tool_use_ids: set[str] = set()
     for chain_idx, (ref, stub_user, stub_asst) in collapse_map.items():
         chain = pairs[chain_idx]
         for gi in chain:
             collapsed_indices.add(gi)
+            msg = messages[gi]
+            if not isinstance(msg, dict):
+                continue
+            content = msg.get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if (
+                        isinstance(block, dict)
+                        and block.get("type") == "tool_use"
+                    ):
+                        _tid = block.get("id")
+                        if _tid:
+                            collapsed_tool_use_ids.add(_tid)
 
     # Build index → insertion stubs map
     insert_at: dict[int, tuple[dict, dict]] = {}
@@ -1655,7 +1733,23 @@ def collapse_turn_chains(
                 new_messages.append(stub_asst)
             # else: skip (interior of a collapsed chain)
         else:
-            new_messages.append(messages[mi])
+            msg = messages[mi]
+            # Strip orphaned tool_result blocks whose tool_use was collapsed
+            if collapsed_tool_use_ids and isinstance(msg, dict):
+                content = msg.get("content", [])
+                if isinstance(content, list):
+                    cleaned = [
+                        block for block in content
+                        if not (
+                            isinstance(block, dict)
+                            and block.get("type") == "tool_result"
+                            and block.get("tool_use_id") in collapsed_tool_use_ids
+                        )
+                    ]
+                    if len(cleaned) != len(content):
+                        msg = dict(msg)
+                        msg["content"] = cleaned if cleaned else [{"type": "text", "text": "[tool results removed — parent tool call was compacted]"}]
+            new_messages.append(msg)
 
     body = dict(body)
     body[_msg_key] = new_messages

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/proxy/server.py

@@ -455,6 +455,7 @@ async def prepare_payload(
                 pre_filter_body=None,
                 paging_enabled=False,
                 tool_output_find_quote=False,
+                restore_tool_injected=False,
                 inbound_bytes=_inbound_bytes,
                 outbound_bytes=_outbound_bytes,
             )
@@ -684,6 +685,7 @@ async def prepare_payload(
             logger.info("TOOL-OUTPUT Injected vc_find_quote tool for truncated output retrieval")
 
     # Inject vc_restore_tool when stubs are present but paging didn't already inject it
+    _restore_tool_injected = False
     if _tool_stubs_present and not paging_enabled and fmt.supports_tool_interception:
         existing_names = {t.get("name") for t in enriched_body.get("tools", []) if isinstance(t, dict)}
         if "vc_restore_tool" not in existing_names:
@@ -691,8 +693,15 @@ async def prepare_payload(
             _restore_def = [d for d in vc_tool_definitions() if d["name"] == "vc_restore_tool"]
             if _restore_def:
                 enriched_body = fmt.inject_tools(enriched_body, _restore_def)
+                _restore_tool_injected = True
                 logger.info("TOOL-STUB Injected vc_restore_tool for stub restoration")
 
+    # Sanitize stale vc_restore_tool errors from history so the model isn't
+    # poisoned by previous client-side "No such tool" rejections.
+    if _restore_tool_injected or paging_enabled:
+        from .message_filter import sanitize_vc_tool_errors
+        enriched_body = sanitize_vc_tool_errors(enriched_body, fmt)
+
     # Track enriched payload size
     if state:
         state._last_enriched_payload_kb = round(len(json.dumps(enriched_body)) / 1024, 1)
@@ -1006,6 +1015,7 @@ async def prepare_payload(
         pre_filter_body=_pre_filter_body,
         paging_enabled=paging_enabled,
         tool_output_find_quote=tool_output_find_quote,
+        restore_tool_injected=_restore_tool_injected,
         inbound_bytes=_inbound_bytes,
         outbound_bytes=_outbound_bytes,
     )
@@ -1387,7 +1397,7 @@ def create_app(
                     request_log_dir=_effective_log_dir, log_prefix=_log_prefix,
                 )
         else:
-            _intercept_vc_tools = result.paging_enabled or result.tool_output_find_quote
+            _intercept_vc_tools = result.paging_enabled or result.tool_output_find_quote or result.restore_tool_injected
 
             if result.is_streaming:
                 return await _handle_streaming(

{virtual_context-0.2.2 → virtual_context-0.2.3}/virtual_context/types.py

@@ -904,6 +904,7 @@ class PreparedPayload:
     pre_filter_body: dict | None  # body before filtering (for metrics capture)
     paging_enabled: bool
     tool_output_find_quote: bool
+    restore_tool_injected: bool
     inbound_bytes: int
     outbound_bytes: int
     metadata: dict = field(default_factory=dict)  # catch-all for anything else