Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(vibey): preserve hosted refusal render compatibility (#3106)
Call Whitefe232eac2de5
diff --git a/core/agent_core/ai/hosted.py b/core/agent_core/ai/hosted.pyindex 63bfd6978..c82a32330 100644--- a/core/agent_core/ai/hosted.py+++ b/core/agent_core/ai/hosted.py@@ -549,7 +549,12 @@ class PortableHosted(NamedTuple):def portable_hosted(- message: AssistantMessage, *, in_flight: bool, interrupted: str, parallel_group: bool = False+ message: AssistantMessage,+ *,+ in_flight: bool,+ interrupted: str,+ parallel_group: bool = False,+ omit_pending: bool = False,) -> dict[int, PortableHosted]:"""Each hosted call of a replayed response in portable form (§4.4, §5), keyed by the block's identity.@@ -561,6 +566,9 @@ def portable_hosted(The posts the answer cites are listed once, on its first call that was not cut off, whichever form it takes.``interrupted`` is the result of a synthetic call cut off with its turn. A deferred mixed ``parallel_group``is rendered intact by the caller, so calls after a client call can also be synthetic without splitting it.+ ``omit_pending`` selects B after an explicit hosted-payload refusal: an unexecuted pending native call is omitted+ rather than represented by Avibe-authored ``no result`` text. Completed, failed and incomplete records retain+ their portable result semantics."""blocks = [block for block in message.content if isinstance(block, HostedToolBlock)]@@ -573,6 +581,9 @@ def portable_hosted(in_place = in_place or (not parallel_group and isinstance(block, ToolCallBlock))continuecited = summary.cited_sources if summary is not None and block is owner else ()+ if omit_pending and block.record.status == "pending":+ plan[id(block)] = PortableHosted("omit")+ continueif in_place:plan[id(block)] = PortableHosted("in_place", text=in_place_text(block, cited=cited))continuediff --git a/core/agent_core/ai/transform.py b/core/agent_core/ai/transform.pyindex cffa5c930..4b50f778a 100644--- a/core/agent_core/ai/transform.py+++ b/core/agent_core/ai/transform.py@@ -18,6 +18,7 @@ from core.agent_core.ai.provider import ModelEndpoint, OpaquePayloadfrom core.agent_core.messages import (AssistantMessage,AssistantContent,+ HOSTED_RENDER_EPOCH,HostedToolBlock,ImageBlock,Message,@@ -147,7 +148,11 @@ def transform_messages(endpoint=endpoint, target=target, protocol=target_protocol)hosted = {} if verbatim else portable_hosted(- message, in_flight=in_flight, interrupted=SYNTHETIC_TOOL_RESULT, parallel_group=position in parallel_groups+ message,+ in_flight=in_flight,+ interrupted=SYNTHETIC_TOOL_RESULT,+ parallel_group=position in parallel_groups,+ omit_pending=_omit_refused_pending(message, position, messages, endpoint, target_protocol),)# The synthetic results of the current run of hosted calls, and the assistant parts they split off.results: list[ToolResultMessage] = []@@ -167,6 +172,8 @@ def transform_messages(continueif isinstance(block, HostedToolBlock):portable = hosted[id(block)]+ if portable.kind == "omit":+ continueif portable.kind == "in_place":split()content.append(TextBlock(text=portable.text))@@ -332,6 +339,37 @@ def in_flight_position(messages: list[Message] | tuple[Message, ...]) -> int | Nreturn None+def _has_signed_thinking(message: AssistantMessage) -> bool:+ return any(isinstance(block, ThinkingBlock) and block.signature is not None for block in message.content)+++def _omit_refused_pending(+ message: AssistantMessage,+ position: int,+ messages: tuple[Message, ...],+ endpoint: ModelEndpoint | None,+ protocol: str,+) -> bool:+ """Select B after an explicit hosted-payload refusal without changing old signed history back and forth.++ A response's own marker says that the new renderer was available when it was committed, but it does not say how+ that response rendered its predecessors. Later signed responses are the binding evidence: if any later one is an+ old unmarked response, this response retains the released X* rendering; otherwise B is stable for this suffix.+ """++ if protocol != "anthropic" or endpoint is None or message.source_identity is None:+ return False+ if (message.source_identity, "hosted") not in endpoint.opaque_refused:+ return False+ if message.hosted_render_epoch != HOSTED_RENDER_EPOCH:+ return False+ return all(+ not _has_signed_thinking(later) or later.hosted_render_epoch == HOSTED_RENDER_EPOCH+ for later in messages[position + 1 :]+ if isinstance(later, AssistantMessage)+ )++def _opaque_admitted(message: AssistantMessage, endpoint: ModelEndpoint | None, payload: OpaquePayload) -> bool:"""Whether ``message``'s opaque payloads of kind ``payload`` may go to ``endpoint``: a hop of the Source identitythat served it, whose provider has not refused that kind in this Session (§3.5)."""diff --git a/core/agent_core/messages.py b/core/agent_core/messages.pyindex 844d55be5..e82ddfe4d 100644--- a/core/agent_core/messages.py+++ b/core/agent_core/messages.py@@ -23,6 +23,11 @@ PROTOCOLS: tuple[str, ...] = ("anthropic", "openai_chat", "openai_responses", "gStopReason = Literal["stop", "length", "tool_use", "refusal", "safety", "aborted", "error"]STOP_REASONS: tuple[str, ...] = ("stop", "length", "tool_use", "refusal", "safety", "aborted", "error")+#: The persisted response metadata epoch for the hosted-refusal wire renderer. It is deliberately not part of+#: the canonical message payload: older releases ignore the row metadata, while this build uses it to keep a+#: response's historical rendering stable across later requests.+HOSTED_RENDER_EPOCH = 2+IMAGE_MIME_TYPES: tuple[str, ...] = ("image/png", "image/jpeg", "image/gif", "image/webp")_LARGE_REF_RE = re.compile(r"^sha256:[0-9a-f]{64}$")@@ -848,6 +853,9 @@ class AssistantMessage:#: Provider classification carried to the store as response-row metadata, not a canonical message field.#: A later hop can distinguish transient cut-offs without interpreting provider wording as capability evidence.error_kind: Optional[str] = field(default=None, compare=False, repr=False)+ #: The response-row metadata epoch used by the hosted-refusal renderer. This transient fact is loaded from the+ #: response metadata and is intentionally omitted from ``message_to_dict`` / the canonical transcript payload.+ hosted_render_epoch: Optional[int] = field(default=None, compare=False, repr=False)def __post_init__(self) -> None:_require_blocks(self.content, (TextBlock, ThinkingBlock, ToolCallBlock, HostedToolBlock), "assistant message")diff --git a/docs/plans/vibey-hosted-tools.md b/docs/plans/vibey-hosted-tools.mdindex cb0c557f0..a61648f84 100644--- a/docs/plans/vibey-hosted-tools.md+++ b/docs/plans/vibey-hosted-tools.md@@ -373,6 +373,7 @@ failover, and is refused unpinned (C-6 item 7). What changes is what happens aftmodel of the same Source may run the tool), when the refusal is first learned, and again onlyafter the record is cleared (by the user or a stamp change) and the tool is tried natively once more. The upstream is not called twicefor nothing: a refusal before output costs no output tokens.+- **Hosted-refusal rendering is versioned.** When an Anthropic hop has explicit `opaque_refused(hosted)` evidence and the refused hosted call is still pending (so Vibey did not execute it), a response written with `hosted_render_epoch=2` omits that call from the portable assistant wire instead of inventing an Avibe `no result` text. This applies only to that refusal state; completed, failed, incomplete, other protocols and ordinary portable fallbacks keep their existing rendering. The epoch lives in response-row metadata, never in the canonical message payload. A later signed-thinking response without the new epoch keeps the suffix on the old renderer, so upgrading cannot rewrite an already-signed history halfway through a Session; once all later signed responses carry epoch 2, new responses use the omission renderer consistently.- **The gateway never rewrites hosted content.** Vibey renders every request from its canonical records; the gatewaynever swaps declarations or converts history. C-6 item 6's opaque thinking strip still applies to unpinnedrequests only.diff --git a/modules/agents/vibey/agent.py b/modules/agents/vibey/agent.pyindex f6f549967..232f774e9 100644--- a/modules/agents/vibey/agent.py+++ b/modules/agents/vibey/agent.py@@ -68,6 +68,7 @@ from core.agent_core.ai.transform import in_flight_positionfrom core.agent_core.tools.base import CallInstancefrom core.agent_core.tools.jobs import call_instancefrom core.agent_core.messages import (+ HOSTED_RENDER_EPOCH,HOSTED_RESULT_TOOLS,HostedImage,IMAGE_MIME_TYPES,@@ -1972,10 +1973,13 @@ class VibeyAgent(BaseAgent):run = self._run_for(session_id, None)current = getattr(getattr(run, "router", None), "current", None)routes = getattr(getattr(current, "endpoint", None), "hosted_tools", {})- return response_recovery_metadata(message, (- tool for tool, route in routes.items()- if route.mode == "proxy" and route.route_switch == "native_interrupted"- ))+ return {+ **response_recovery_metadata(message, (+ tool for tool, route in routes.items()+ if route.mode == "proxy" and route.route_switch == "native_interrupted"+ )),+ "hosted_render_epoch": HOSTED_RENDER_EPOCH,+ }def _on_response(self,diff --git a/storage/agent_transcript.py b/storage/agent_transcript.pyindex 186ff5d3c..d1861860f 100644--- a/storage/agent_transcript.py+++ b/storage/agent_transcript.py@@ -66,7 +66,7 @@ from __future__ import annotationsimport asyncioimport json-from dataclasses import dataclass+from dataclasses import dataclass, replacefrom datetime import datetime, timezonefrom typing import Any, Callable, Literal, Mapping, Optional, Sequence, TypeVar@@ -322,20 +322,25 @@ class SQLiteTranscriptStore:) -> ContextEntry:if not isinstance(message, AssistantMessage):raise TypeError("append_response takes an AssistantMessage")- response: dict[str, Any] = {"version": PAYLOAD_VERSION, "message": message_to_dict(message)}+ row_metadata = dict(metadata or {})+ stored_message = message+ epoch = row_metadata.get("hosted_render_epoch")+ if isinstance(epoch, int) and not isinstance(epoch, bool):+ stored_message = replace(message, hosted_render_epoch=epoch)+ response: dict[str, Any] = {"version": PAYLOAD_VERSION, "message": message_to_dict(stored_message)}if request is not None:response["request"] = dict(request) # C-9 ``ModelResponse.request``: the anchor's request factsmodel = _canonical(response, "response")if replied is None:- replied = has_reply(message)- display_text = self._render(message, final=final, replied=replied, images=tuple(images))+ replied = has_reply(stored_message)+ display_text = self._render(stored_message, final=final, replied=replied, images=tuple(images))def work(conn: Connection) -> ContextEntry:origin = _turn_origin(conn, session_id, agent_name, turn_id)seq = _next_context_seq(conn, session_id)- row_metadata = dict(metadata or {})+ row_metadata_for_write = dict(row_metadata)if origin.turn_id:- row_metadata["turn_id"] = origin.turn_id+ row_metadata_for_write["turn_id"] = origin.turn_idrow = messages_service.append(conn,scope_id=origin.scope_id,@@ -349,12 +354,12 @@ class SQLiteTranscriptStore:),text=display_text,content={"model": model},- metadata=row_metadata or None,+ metadata=row_metadata_for_write or None,)conn.execute(messages.update().where(messages.c.id == row["id"]).values(context_seq=seq))- _register_images(conn, origin.scope_id, session_id, message)+ _register_images(conn, origin.scope_id, session_id, stored_message)return ContextEntry(- session_id, seq, "response", row["id"], message=message, payload=model, created_at=_epoch(row["created_at"])+ session_id, seq, "response", row["id"], message=stored_message, payload=model, created_at=_epoch(row["created_at"]))return await self._write(session_id, work)@@ -982,7 +987,7 @@ def _context_entries(conn: Connection, session_id: str) -> list[ContextEntry]:def _context_rows(conn: Connection, session_id: str, bound: Optional[int]) -> list[ContextEntry]:entries: list[ContextEntry] = []for table, columns, to_entry in (- (messages, (messages.c.type,), _message_entry),+ (messages, (messages.c.type, messages.c.metadata_json), _message_entry),(agent_events, (agent_events.c.event_type, agent_events.c.visibility), _event_entry),):conditions = [table.c.session_id == session_id, table.c.context_seq.is_not(None)]@@ -1001,7 +1006,7 @@ def _turn_context_entries(conn: Connection, session_id: str, turn_id: str) -> li"""Read one Turn through its owner indexes, without loading Session history or forks."""entries: list[ContextEntry] = []for table, index, owner, columns, to_entry in (- ("messages", "ix_messages_turn_id", MESSAGE_TURN_ID_SQL, "type", _message_entry),+ ("messages", "ix_messages_turn_id", MESSAGE_TURN_ID_SQL, "type, metadata_json", _message_entry),("agent_events", "ix_agent_events_turn_sequence_id", "turn_id", "event_type, visibility", _event_entry),):query = text(@@ -1038,6 +1043,14 @@ def _message_entry(session_id: str, row: Mapping[str, Any]) -> ContextEntry:raise TranscriptError(f"context row {row_id} has message type {row['type']!r}")payload = _versioned(_json_object(row["content_json"], row_id).get("model"), row_id)message = _message(payload.get("message"), expected, row_id)+ if isinstance(message, AssistantMessage):+ try:+ metadata = _json_object(row.get("metadata_json"), row_id)+ except TranscriptError:+ metadata = {}+ epoch = metadata.get("hosted_render_epoch")+ if isinstance(epoch, int) and not isinstance(epoch, bool):+ message = replace(message, hosted_render_epoch=epoch)return ContextEntry(session_id, row["context_seq"], kind, row_id, message=message, payload=payload, created_at=_epoch(row["created_at"]))diff --git a/tests/agent_core/ai/test_hosted_transform.py b/tests/agent_core/ai/test_hosted_transform.pyindex 7883e4ac3..31c964a89 100644--- a/tests/agent_core/ai/test_hosted_transform.py+++ b/tests/agent_core/ai/test_hosted_transform.py@@ -12,7 +12,7 @@ import itertoolsimport pytest-from core.agent_core.ai.provider import ModelEndpoint, ModelRequest+from core.agent_core.ai.provider import HostedToolRoute, ModelEndpoint, ModelRequestfrom tests.agent_core.ai._wire import build_wire_requestfrom core.agent_core.ai.transform import SYNTHETIC_TOOL_RESULT, transform_messagesfrom core.agent_core.messages import (@@ -168,6 +168,119 @@ def _transformed(*history):return list(transform_messages(history, target=Origin("anthropic", "anthropic", "claude-opus-5-5")))+def test_a_refused_pending_hosted_call_is_omitted_without_touching_signed_thinking():+ target = Origin("anthropic", "anthropic", "claude-opus-5-5")+ pending = _hosted("ws_pending", "web_search", HostedAction("search", queries=("q",)), HostedRecord(status="pending"))+ thinking = ThinkingBlock(text="", signature="signed")+ client = ToolCallBlock("toolu_read", "read", {"path": "a"})+ response = AssistantMessage(+ (thinking, pending, client), target, "tool_use", hosted_summary=HostedSummary(), source_identity="identity",+ hosted_render_epoch=2,+ )+ endpoint = ModelEndpoint(+ "anthropic", "http://hub.invalid/vibey/v1", target.model, "hub-token", provider="anthropic",+ source_id=SOURCE, source_identity="identity",+ hosted_tools={"web_search": HostedToolRoute("native", True, declaration={"type": "web_search_20250305"})},+ opaque_refused=frozenset({("identity", "hosted")}),+ )++ result = transform_messages(+ (UserMessage((TextBlock("go"),)), response, ToolResultMessage("toolu_read", "read", (TextBlock("contents"),))),+ target=target,+ protocol="anthropic",+ endpoint=endpoint,+ )++ sent = result.messages[1]+ assert isinstance(sent, AssistantMessage)+ assert sent.content == (thinking, client)+ assert not any(isinstance(block, TextBlock) and "no result" in block.text for block in sent.content)+++def test_refused_pending_hosted_render_keeps_legacy_shape_until_later_signed_history_is_new():+ target = Origin("anthropic", "anthropic", "claude-opus-5-5")+ pending = _hosted("ws_pending", "web_search", HostedAction("search", queries=("q",)), HostedRecord(status="pending"))+ response = AssistantMessage(+ (ThinkingBlock(text="", signature="signed"), ToolCallBlock("toolu_read", "read", {}), pending),+ target, "tool_use", hosted_summary=HostedSummary(), source_identity="identity", hosted_render_epoch=2,+ )+ later = AssistantMessage(+ (ThinkingBlock(text="later", signature="older-signature"), TextBlock(text="later")), target, "stop"+ )+ endpoint = ModelEndpoint(+ "anthropic", "http://hub.invalid/vibey/v1", target.model, "hub-token", provider="anthropic",+ source_id=SOURCE, source_identity="identity",+ hosted_tools={"web_search": HostedToolRoute("native", True, declaration={"type": "web_search_20250305"})},+ opaque_refused=frozenset({("identity", "hosted")}),+ )++ result = transform_messages(+ (UserMessage((TextBlock("go"),)), response, ToolResultMessage("toolu_read", "read", (TextBlock("contents"),)), later),+ target=target,+ protocol="anthropic",+ endpoint=endpoint,+ )++ sent = result.messages[1]+ assert isinstance(sent, AssistantMessage)+ assert any(isinstance(block, TextBlock) and block.text.endswith("(no result)") for block in sent.content)+++def test_legacy_refused_pending_response_stays_legacy_after_new_epoch_history():+ target = Origin("anthropic", "anthropic", "claude-opus-5-5")+ pending = _hosted("ws_pending", "web_search", HostedAction("search", queries=("q",)), HostedRecord(status="pending"))+ response = AssistantMessage(+ (ThinkingBlock(text="", signature="signed"), pending),+ target, "tool_use", hosted_summary=HostedSummary(), source_identity="identity",+ )+ later = AssistantMessage(+ (ThinkingBlock(text="later", signature="new-signature"), TextBlock(text="later")), target, "stop",+ hosted_render_epoch=2,+ )+ endpoint = ModelEndpoint(+ "anthropic", "http://hub.invalid/vibey/v1", target.model, "hub-token", provider="anthropic",+ source_id=SOURCE, source_identity="identity",+ hosted_tools={"web_search": HostedToolRoute("native", True, declaration={"type": "web_search_20250305"})},+ opaque_refused=frozenset({("identity", "hosted")}),+ )++ result = transform_messages(+ (UserMessage((TextBlock("go"),)), response, later),+ target=target,+ protocol="anthropic",+ endpoint=endpoint,+ )++ sent = result.messages[1]+ assert isinstance(sent, AssistantMessage)+ assert any(isinstance(block, ToolCallBlock) for block in sent.content)+++def test_refused_pending_hosted_b_does_not_change_non_anthropic_targets():+ target = Origin("google", "openai_chat", "gemini-3-pro")+ pending = _hosted("ws_pending", "web_search", HostedAction("search", queries=("q",)), HostedRecord(status="pending"))+ response = AssistantMessage(+ (ThinkingBlock(text="", signature="signed"), pending, ToolCallBlock("toolu_read", "read", {})),+ Origin("anthropic", "anthropic", "claude-opus-5-5"), "tool_use", hosted_summary=HostedSummary(),+ source_identity="identity", hosted_render_epoch=2,+ )+ endpoint = ModelEndpoint(+ "openai_chat", "http://hub.invalid/v1", target.model, "hub-token", provider="google",+ source_id=SOURCE, source_identity="identity", hosted_tools={}, opaque_refused=frozenset({("identity", "hosted")}),+ )++ result = transform_messages(+ (UserMessage((TextBlock("go"),)), response, ToolResultMessage("toolu_read", "read", (TextBlock("contents"),))),+ target=target,+ protocol="openai_chat",+ endpoint=endpoint,+ )++ sent = result.messages[1]+ assert isinstance(sent, AssistantMessage)+ assert any(isinstance(block, TextBlock) and block.text.endswith("(no result)") for block in sent.content)++def test_every_hosted_call_is_its_own_synthetic_call_and_a_page_action_says_what_it_did():"""§5 as implemented (option b): no action folds into another call's result. A page action is its own call whosequery names it, and its completed result says what it did."""diff --git a/tests/test_agent_transcript.py b/tests/test_agent_transcript.pyindex 18749280e..098ec1eec 100644--- a/tests/test_agent_transcript.py+++ b/tests/test_agent_transcript.py@@ -19,6 +19,7 @@ from sqlalchemy import selectfrom core.agent_core.messages import (AssistantMessage,+ HOSTED_RENDER_EPOCH,HostedAction,HostedNative,HostedRecord,@@ -37,6 +38,7 @@ from core.agent_core.messages import (text,)from config.paths import get_sqlite_state_path+from modules.agents.vibey.store import AdapterTranscriptStorefrom storage import message_deliveries, messages_servicefrom storage.agent_transcript import SQLiteTranscriptStore, TranscriptError, resolve_fork_pointfrom storage.db import create_sqlite_engine@@ -308,6 +310,35 @@ async def test_recovery_facts_survive_without_changing_message_contract(engine,assert "native_search_recovery" not in model+async def test_hosted_render_epoch_is_response_metadata_not_canonical_message_content(engine):+ with engine.begin() as conn:+ home = _scope(conn, "C-hosted-render-epoch")+ _session(conn, "ses_hosted_render_epoch", home)+ consumed = _row(conn, "ses_hosted_render_epoch", home, "go")+ store = AdapterTranscriptStore(+ SQLiteTranscriptStore(engine),+ engine,+ environment=lambda _: {},+ on_response=lambda *_: None,+ response_metadata=lambda *_: {+ "hosted_render_epoch": HOSTED_RENDER_EPOCH,+ "future_metadata": "ignored by the model payload",+ },+ )+ await store.consume_input("ses_hosted_render_epoch", consumed, _user("go"))+ written = await store.append_response("ses_hosted_render_epoch", _assistant("stored"), final=True)++ loaded = list(await store.load("ses_hosted_render_epoch"))+ restored = loaded[1].message+ assert isinstance(restored, AssistantMessage)+ assert restored.hosted_render_epoch == HOSTED_RENDER_EPOCH+ with engine.connect() as conn:+ row = conn.execute(select(messages).where(messages.c.id == written.row_id)).mappings().one()+ model = json.loads(row["content_json"])["model"]["message"]+ assert "hosted_render_epoch" not in model+ assert "future_metadata" not in model++async def test_a_stored_unknown_native_hosted_row_loads_through_the_transcript_owner(engine):with engine.begin() as conn:home = _scope(conn, "C-hosted-history")