feat(weave): store call views in CallViewSpec objects

Changes view storage from summary.weave.views blob to a dedicated CallViewSpec
object referenced by view_spec_ref. This enables content-addressed deduplication
of identical view configurations across calls.

Changes:
- Add CallViewSpec builtin object class with typed view item schemas
- Register CallViewSpec in builtin_object_registry
- Add _pending_views field to Call for collecting views during execution
- Update set_call_view to store in _pending_views instead of summary
- Add build_and_save_call_view_spec to create and save CallViewSpec at call_end
- Update weave_client to call build_and_save_call_view_spec and set view_spec_ref
- Update tests to verify new storage format

Author: bcsherma

tests/trace/test_current_call.py

@@ -73,13 +73,13 @@ def my_op():
 
 
 def test_set_view_inside_op(client):
-    """Verify weave.set_view stores serialized content on op call summary."""
+    """Verify weave.set_view creates a CallViewSpec object and sets view_spec_ref."""
     markdown_view = weave.Content.from_text("# Report", mimetype="text/markdown")
     html_view = weave.Content.from_text("<p>Hi</p>", mimetype="text/html")
 
     @weave.op
     def my_op_with_views() -> str:
-        """Op that attaches two views to its call summary.
+        """Op that attaches two views via CallViewSpec.
 
         Returns:
             str: Constant string to keep output simple.
@@ -98,20 +98,23 @@ def my_op_with_views() -> str:
     calls = list(client.get_calls())
     assert len(calls) == 1
     call = calls[0]
-    assert call.summary["weave"] is not None
-    assert "views" in call.summary["weave"]
-    views = call.summary["weave"]["views"]
-    assert len(views) == 2
-    assert views["markdown"] == to_json(
-        markdown_view,
-        client._project_id(),
-        client,
-    )
-    assert views["html"] == to_json(
-        html_view,
-        client._project_id(),
-        client,
-    )
+
+    # Views are now stored in view_spec_ref, not summary
+    assert call.view_spec_ref is not None
+    assert "weave:///" in call.view_spec_ref
+    assert "CallViewSpec" in call.view_spec_ref
+
+    # Retrieve the CallViewSpec object
+    from weave.trace.refs import ObjectRef
+
+    ref = ObjectRef.parse_uri(call.view_spec_ref)
+    view_spec = ref.get()
+
+    # Verify the views are present
+    assert "markdown" in view_spec.views
+    assert "html" in view_spec.views
+    assert view_spec.views["markdown"].type == "content"
+    assert view_spec.views["html"].type == "content"
 
 
 def test_set_view_string_content(client):
@@ -125,10 +128,18 @@ def op_with_string_view() -> None:
     op_with_string_view()
 
     call = client.get_calls()[0]
-    assert call.summary["weave"] is not None
-    views = call.summary["weave"]["views"]
-    stored = dict(views["md"])
 
-    assert stored["_type"] == "CustomWeaveType"
-    assert stored["weave_type"]["type"] == "weave.type_wrappers.Content.content.Content"
-    assert stored["files"]["content"]
+    # Views are stored in view_spec_ref
+    assert call.view_spec_ref is not None
+
+    # Retrieve the CallViewSpec object
+    from weave.trace.refs import ObjectRef
+
+    ref = ObjectRef.parse_uri(call.view_spec_ref)
+    view_spec = ref.get()
+
+    # Verify the markdown view is present
+    assert "md" in view_spec.views
+    view_item = view_spec.views["md"]
+    assert view_item.type == "content"
+    assert view_item.mimetype == "text/markdown"

weave/trace/call.py

@@ -82,6 +82,9 @@ class Call:
     _children: list[Call] = dataclasses.field(default_factory=list)
     _feedback: RefFeedbackQuery | None = None
 
+    # Pending views to be saved as CallViewSpec object at call_end
+    _pending_views: dict[str, Any] = dataclasses.field(default_factory=dict)
+
     # Size of metadata storage for this call
     storage_size_bytes: int | None = None
 

weave/trace/view_utils.py

@@ -2,16 +2,31 @@
 
 from __future__ import annotations
 
-from typing import Any
+import base64
+from typing import TYPE_CHECKING, Any
 
 from weave.trace.call import Call
+from weave.trace.refs import ObjectRef
 from weave.trace.serialization.serialize import to_json
 from weave.trace.table import Table
-from weave.trace.weave_client import WeaveClient
-from weave.trace.widgets import Widget
+from weave.trace.widgets import ChildPredictionsWidget, ScoreSummaryWidget, Widget
+from weave.trace_server.interface.builtin_object_classes.call_view_spec import (
+    CallViewSpec,
+    ChildPredictionsWidgetItem,
+    ContentViewItem,
+    ObjectRefViewItem,
+    ScoreSummaryWidgetItem,
+    TableRefViewItem,
+)
+from weave.trace_server.interface.builtin_object_classes.call_view_spec import (
+    ViewItem as CallViewSpecItem,
+)
 from weave.type_wrappers.Content.content import Content
 
-ViewItem = Content | str | Widget | Table
+if TYPE_CHECKING:
+    from weave.trace.weave_client import WeaveClient
+
+ViewItem = Content | str | Widget | Table | ObjectRef
 ViewSpec = ViewItem | list[ViewItem]
 
 
@@ -148,6 +163,101 @@ def serialize_view_spec(
         )
 
 
+def _sdk_view_item_to_call_view_spec_item(
+    item: ViewItem,
+    client: WeaveClient,
+    *,
+    extension: str | None = None,
+    mimetype: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    encoding: str = "utf-8",
+) -> CallViewSpecItem:
+    """Convert an SDK view item to a CallViewSpec item for storage.
+
+    Args:
+        item: A Content, string, Widget, or Table to convert.
+        client: The WeaveClient for saving tables.
+        extension: Optional file extension for string content.
+        mimetype: Optional MIME type for string content.
+        metadata: Optional metadata for string content.
+        encoding: Encoding for string content.
+
+    Returns:
+        A CallViewSpec item (ContentViewItem, WidgetItem, or TableRefViewItem).
+    """
+    if isinstance(item, ScoreSummaryWidget):
+        return ScoreSummaryWidgetItem()
+    elif isinstance(item, ChildPredictionsWidget):
+        return ChildPredictionsWidgetItem()
+    elif isinstance(item, Widget):
+        # Future widgets - default to score_summary for now
+        return ScoreSummaryWidgetItem()
+    elif isinstance(item, Table):
+        # Publish the table and return its ref URI
+        table_ref = client._save_table(item)
+        return TableRefViewItem(uri=table_ref.uri())
+    elif isinstance(item, ObjectRef):
+        # Store object references (e.g., SavedView) as URI strings
+        return ObjectRefViewItem(uri=item.uri())
+    elif isinstance(item, (Content, str)):
+        content_obj = resolve_view_content(
+            item,
+            extension=extension,
+            mimetype=mimetype,
+            metadata=metadata,
+            encoding=encoding,
+        )
+        # Encode content data as base64
+        data_bytes = (
+            content_obj.data
+            if isinstance(content_obj.data, bytes)
+            else content_obj.data.encode(content_obj.encoding or "utf-8")
+        )
+        return ContentViewItem(
+            mimetype=content_obj.mimetype,
+            encoding=content_obj.encoding,
+            data=base64.b64encode(data_bytes).decode("ascii"),
+            metadata=content_obj.metadata,
+        )
+    else:
+        raise TypeError(f"Unsupported view item type: {type(item)}")
+
+
+def _sdk_view_spec_to_call_view_spec_item(
+    spec: ViewSpec,
+    client: WeaveClient,
+    *,
+    extension: str | None = None,
+    mimetype: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    encoding: str = "utf-8",
+) -> CallViewSpecItem | list[CallViewSpecItem]:
+    """Convert an SDK view spec to CallViewSpec item(s).
+
+    Args:
+        spec: A single view item or list of view items.
+        client: The WeaveClient for saving tables.
+        extension: Optional file extension for string content.
+        mimetype: Optional MIME type for string content.
+        metadata: Optional metadata for string content.
+        encoding: Encoding for string content.
+
+    Returns:
+        A CallViewSpec item or list of items.
+    """
+    if isinstance(spec, list):
+        return [_sdk_view_item_to_call_view_spec_item(item, client) for item in spec]
+    else:
+        return _sdk_view_item_to_call_view_spec_item(
+            spec,
+            client,
+            extension=extension,
+            mimetype=mimetype,
+            metadata=metadata,
+            encoding=encoding,
+        )
+
+
 def set_call_view(
     *,
     call: Call,
@@ -159,12 +269,16 @@ def set_call_view(
     metadata: dict[str, Any] | None = None,
     encoding: str = "utf-8",
 ) -> None:
-    """Attach serialized content to the provided call's summary under `weave.views`.
+    """Attach a view to the call's pending views for later storage as CallViewSpec.
+
+    Views are stored in the call's _pending_views dict and will be converted to
+    a CallViewSpec object when the call is finished. This allows deduplication
+    of identical view configurations across calls.
 
     Args:
-        call: The call whose summary should receive the view entry.
+        call: The call whose pending views should receive the view entry.
         client: The active ``WeaveClient`` used for serialization.
-        name: Key to store the view under within ``summary.weave.views``.
+        name: Key to store the view under.
         content: A ``weave.Content``, raw text, ``Widget``, ``Table``, or list of these
             to serialize into the view.
         extension: Optional file extension used when converting text content.
@@ -189,35 +303,46 @@ def set_call_view(
         ...     extension="html",
         ... )
     """
-    if call.summary is None:
-        call.summary = {}
-
-    summary = call.summary
-
-    weave_bucket = summary.get("weave")
-    if not isinstance(weave_bucket, dict):
-        weave_bucket = {}
-        summary["weave"] = weave_bucket
-
-    legacy_views = summary.get("views")
-    if isinstance(legacy_views, dict):
-        summary.pop("views", None)
-    views = weave_bucket.get("views")
-
-    if not isinstance(views, dict):
-        views = {}
-        weave_bucket["views"] = views
-
-    if isinstance(legacy_views, dict):
-        views.update(legacy_views)
-
-    project_id = client._project_id()
-    views[name] = serialize_view_spec(
+    # Store the converted view item in _pending_views
+    call._pending_views[name] = _sdk_view_spec_to_call_view_spec_item(
         content,
-        project_id,
         client,
         extension=extension,
         mimetype=mimetype,
         metadata=metadata,
         encoding=encoding,
     )
+
+
+def build_and_save_call_view_spec(
+    call: Call,
+    client: WeaveClient,
+) -> str | None:
+    """Build a CallViewSpec from pending views and save it as an object.
+
+    This function collects all pending views from the call, creates a CallViewSpec
+    object, and saves it to the project. The returned ref URI can be used as the
+    view_spec_ref in the call_end request.
+
+    Args:
+        call: The call with pending views to save.
+        client: The WeaveClient for saving the object.
+
+    Returns:
+        The view_spec_ref URI string, or None if no views are pending.
+    """
+    if not call._pending_views:
+        return None
+
+    # Convert pending views dict values to the proper union type
+    views_dict: dict[str, CallViewSpecItem | list[CallViewSpecItem]] = {}
+    for name, item in call._pending_views.items():
+        views_dict[name] = item
+
+    # Create the CallViewSpec object
+    view_spec = CallViewSpec(views=views_dict)
+
+    # Save as a versioned object - content-addressed storage will deduplicate
+    ref: ObjectRef = client._save_object(view_spec, name="CallViewSpec")
+
+    return ref.uri()

weave/trace/weave_client.py

@@ -84,6 +84,7 @@
 from weave.trace.table_upload_chunking import ChunkingConfig, TableChunkManager
 from weave.trace.util import log_once
 from weave.trace.vals import WeaveObject, WeaveTable, make_trace_obj
+from weave.trace.view_utils import build_and_save_call_view_spec
 from weave.trace.wandb_run_context import (
     WandbRunContext,
     check_wandb_run_matches,
@@ -981,6 +982,9 @@ def send_end_call() -> None:
                 wb_run_context_end.step if wb_run_context_end else None
             )
 
+            # Build and save CallViewSpec if there are pending views
+            view_spec_ref = build_and_save_call_view_spec(call, self)
+
             call_end_req = CallEndReq(
                 end=EndedCallSchemaForInsertWithStartedAt(
                     project_id=project_id,
@@ -991,6 +995,7 @@ def send_end_call() -> None:
                     summary=merged_summary,
                     exception=exception_str,
                     wb_run_step_end=current_wb_run_step_end,
+                    view_spec_ref=view_spec_ref,
                 )
             )
             bytes_size = len(call_end_req.model_dump_json())

weave/trace_server/interface/builtin_object_classes/builtin_object_registry.py

@@ -5,6 +5,9 @@
 from weave.trace_server.interface.builtin_object_classes.base_object_def import (
     BaseObject,
 )
+from weave.trace_server.interface.builtin_object_classes.call_view_spec import (
+    CallViewSpec,
+)
 from weave.trace_server.interface.builtin_object_classes.comparison_view import (
     ComparisonView,
 )
@@ -50,3 +53,4 @@ def register_base_object(cls: type[BaseObject]) -> None:
 register_base_object(ComparisonView)
 register_base_object(LLMStructuredCompletionModel)
 register_base_object(ChartConfig)
+register_base_object(CallViewSpec)