Skip to content

armgit / avibe

Public Imported from GitHub
0

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.

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.py
index 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))
continue
cited = 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")
+ continue
if in_place:
plan[id(block)] = PortableHosted("in_place", text=in_place_text(block, cited=cited))
continue
diff --git a/core/agent_core/ai/transform.py b/core/agent_core/ai/transform.py
index 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, OpaquePayload
from 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(
continue
if isinstance(block, HostedToolBlock):
portable = hosted[id(block)]
+ if portable.kind == "omit":
+ continue
if 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 | N
return 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 identity
that 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.py
index 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", "g
StopReason = 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.md
index 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 aft
model of the same Source may run the tool), when the refusal is first learned, and again only
after the record is cleared (by the user or a stamp change) and the tool is tried natively once more. The upstream is not called twice
for 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 gateway
never swaps declarations or converts history. C-6 item 6's opaque thinking strip still applies to unpinned
requests only.
diff --git a/modules/agents/vibey/agent.py b/modules/agents/vibey/agent.py
index 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_position
from core.agent_core.tools.base import CallInstance
from core.agent_core.tools.jobs import call_instance
from 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.py
index 186ff5d3c..d1861860f 100644
--- a/storage/agent_transcript.py
+++ b/storage/agent_transcript.py
@@ -66,7 +66,7 @@ from __future__ import annotations
import asyncio
import json
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
from datetime import datetime, timezone
from 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 facts
model = _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_id
row = 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.py
index 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 itertools
import pytest
-from core.agent_core.ai.provider import ModelEndpoint, ModelRequest
+from core.agent_core.ai.provider import HostedToolRoute, ModelEndpoint, ModelRequest
from tests.agent_core.ai._wire import build_wire_request
from core.agent_core.ai.transform import SYNTHETIC_TOOL_RESULT, transform_messages
from 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 whose
query names it, and its completed result says what it did."""
diff --git a/tests/test_agent_transcript.py b/tests/test_agent_transcript.py
index 18749280e..098ec1eec 100644
--- a/tests/test_agent_transcript.py
+++ b/tests/test_agent_transcript.py
@@ -19,6 +19,7 @@ from sqlalchemy import select
from 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 AdapterTranscriptStore
from storage import message_deliveries, messages_service
from storage.agent_transcript import SQLiteTranscriptStore, TranscriptError, resolve_fork_point
from 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")