atomic-agents 2.6.0__tar.gz → 2.7.3__tar.gz

atomic_agents-2.7.3/.claude/skills/release/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: release
+description: Release a new version of atomic-agents to PyPI and GitHub. Use when the user asks to "release", "publish", "deploy", or "bump version" for atomic-agents.
+allowed-tools: Read, Bash, Grep, Glob
+---
+
+# Release Process for atomic-agents
+
+## Overview
+
+This skill guides the release process for atomic-agents, including version bumping, PyPI publishing, and GitHub release creation.
+
+## Prerequisites
+
+- Must be on `main` branch with clean working directory
+- `.env` file must contain `PYPI_TOKEN` environment variable
+- Must have push access to the repository
+
+## Release Types
+
+| Type | When to Use | Example |
+|------|-------------|---------|
+| `major` | Breaking changes | 2.5.0 → 3.0.0 |
+| `minor` | New features (backwards compatible) | 2.5.0 → 2.6.0 |
+| `patch` | Bug fixes only | 2.5.0 → 2.5.1 |
+
+## Step-by-Step Process
+
+### 1. Prepare the Branch
+
+```bash
+git checkout main
+git pull
+git status  # Ensure clean working directory
+```
+
+### 2. Run Build and Deploy Script
+
+**Important**: The script bumps versions, so if it fails partway through, reset to main before retrying.
+
+```powershell
+powershell -ExecutionPolicy Bypass -File build_and_deploy.ps1 <major|minor|patch>
+```
+
+This script will:
+- Read current version from `pyproject.toml`
+- Increment version based on release type
+- Update `pyproject.toml` with new version
+- Run `uv sync` to update dependencies
+- Run `uv build` to create distribution packages
+- Run `uv publish` to upload to PyPI
+
+### 3. If Script Fails - Reset and Retry
+
+```bash
+git checkout main
+git reset --hard origin/main
+# Fix the issue, then run script again
+```
+
+### 4. Commit and Push Version Bump
+
+```bash
+git add pyproject.toml uv.lock
+git commit -m "Release vX.Y.Z"
+git push
+```
+
+### 5. Create GitHub Release
+
+```bash
+gh release create vX.Y.Z --title "vX.Y.Z" --notes "RELEASE_NOTES_HERE"
+```
+
+## Release Notes Template
+
+```markdown
+## What's New
+
+### Feature Name
+Brief description of the feature.
+
+#### Features
+- Feature 1
+- Feature 2
+
+#### Improvements
+- Improvement 1
+
+#### Bug Fixes
+- Fix 1
+
+### Full Changelog
+https://github.com/BrainBlend-AI/atomic-agents/compare/vOLD...vNEW
+```
+
+## Checklist
+
+- [ ] On main branch with clean working directory
+- [ ] `.env` file has `PYPI_TOKEN`
+- [ ] Determined correct release type (major/minor/patch)
+- [ ] Build and deploy script completed successfully
+- [ ] Version bump committed and pushed
+- [ ] GitHub release created with release notes

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/.gitignore

@@ -153,6 +153,8 @@ debug.log
 
 # AI tools
 .claude
+!.claude/skills/
+!.claude/skills/**
 CLAUDE.md
 CLAUDE.local.md
 .serena

atomic_agents-2.7.3/.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        args: [--line-length=127]
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+        args: [--max-line-length=127]

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomic-agents
-Version: 2.6.0
+Version: 2.7.3
 Summary: A versatile framework for creating and managing intelligent agents.
 Project-URL: Homepage, https://github.com/BrainBlend-AI/atomic-agents
 Project-URL: Repository, https://github.com/BrainBlend-AI/atomic-agents

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/atomic-agents/atomic_agents/context/chat_history.py

@@ -97,64 +97,92 @@ class ChatHistory:
             either a single JSON string or a mixed array of JSON and multimodal objects.
 
         Note:
-            This method supports multimodal content by keeping multimodal objects
-            separate while generating cohesive JSON for text-based fields.
+            This method supports multimodal content at any nesting depth by
+            recursively extracting multimodal objects and using Pydantic's
+            model_dump_json(exclude=...) for proper serialization of remaining fields.
         """
         history = []
         for message in self.history:
             input_content = message.content
+            multimodal_objects, exclude_spec = self._extract_multimodal_info(input_content)
 
-            # Check if content has any multimodal fields
-            multimodal_objects = []
-            has_multimodal = False
-
-            # Extract multimodal content first
-            for field_name, field in input_content.__class__.model_fields.items():
-                field_value = getattr(input_content, field_name)
-
-                if isinstance(field_value, list):
-                    for item in field_value:
-                        if isinstance(item, INSTRUCTOR_MULTIMODAL_TYPES):
-                            multimodal_objects.append(item)
-                            has_multimodal = True
-                elif isinstance(field_value, INSTRUCTOR_MULTIMODAL_TYPES):
-                    multimodal_objects.append(field_value)
-                    has_multimodal = True
-
-            if has_multimodal:
-                # For multimodal content: create mixed array with JSON + multimodal objects
+            if multimodal_objects:
                 processed_content = []
-
-                # Add single cohesive JSON for all non-multimodal fields
-                non_multimodal_data = {}
-                for field_name, field in input_content.__class__.model_fields.items():
-                    field_value = getattr(input_content, field_name)
-
-                    if isinstance(field_value, list):
-                        # Only include non-multimodal items from lists
-                        non_multimodal_items = [
-                            item for item in field_value if not isinstance(item, INSTRUCTOR_MULTIMODAL_TYPES)
-                        ]
-                        if non_multimodal_items:
-                            non_multimodal_data[field_name] = non_multimodal_items
-                    elif not isinstance(field_value, INSTRUCTOR_MULTIMODAL_TYPES):
-                        non_multimodal_data[field_name] = field_value
-
-                # Add single JSON string if there are non-multimodal fields
-                if non_multimodal_data:
-                    processed_content.append(json.dumps(non_multimodal_data, ensure_ascii=False))
-
-                # Add all multimodal objects
+                content_json = input_content.model_dump_json(exclude=exclude_spec)
+                if content_json and content_json != "{}":
+                    processed_content.append(content_json)
                 processed_content.extend(multimodal_objects)
-
                 history.append({"role": message.role, "content": processed_content})
             else:
-                # No multimodal content: generate single cohesive JSON string
                 content_json = input_content.model_dump_json()
                 history.append({"role": message.role, "content": content_json})
 
         return history
 
+    @staticmethod
+    def _extract_multimodal_info(obj):
+        """
+        Recursively extract multimodal objects and build a Pydantic-compatible exclude spec.
+
+        Walks the object tree to find all Instructor multimodal types (Image, Audio, PDF)
+        at any nesting depth, collecting them into a flat list and building an exclude
+        specification that can be passed to model_dump_json(exclude=...).
+
+        Args:
+            obj: The object to inspect (BaseIOSchema, list, dict, or primitive).
+
+        Returns:
+            tuple: (multimodal_objects, exclude_spec) where:
+                - multimodal_objects: flat list of all multimodal objects found
+                - exclude_spec: Pydantic exclude dict, True (exclude entirely), or None
+        """
+        if isinstance(obj, INSTRUCTOR_MULTIMODAL_TYPES):
+            return [obj], True
+
+        if hasattr(obj, "__class__") and hasattr(obj.__class__, "model_fields"):
+            all_objects = []
+            exclude = {}
+            for field_name in obj.__class__.model_fields:
+                if hasattr(obj, field_name):
+                    field_value = getattr(obj, field_name)
+                    objects, sub_exclude = ChatHistory._extract_multimodal_info(field_value)
+                    if objects:
+                        all_objects.extend(objects)
+                        exclude[field_name] = sub_exclude
+            return all_objects, (exclude if exclude else None)
+
+        if isinstance(obj, (list, tuple)):
+            all_objects = []
+            exclude = {}
+            for i, item in enumerate(obj):
+                objects, sub_exclude = ChatHistory._extract_multimodal_info(item)
+                if objects:
+                    all_objects.extend(objects)
+                    exclude[i] = sub_exclude
+            if not all_objects:
+                return [], None
+            # If every item in the list is fully multimodal, exclude the entire field
+            if len(exclude) == len(obj) and all(v is True for v in exclude.values()):
+                return all_objects, True
+            return all_objects, exclude
+
+        if isinstance(obj, dict):
+            all_objects = []
+            exclude = {}
+            for k, v in obj.items():
+                objects, sub_exclude = ChatHistory._extract_multimodal_info(v)
+                if objects:
+                    all_objects.extend(objects)
+                    exclude[k] = sub_exclude
+            if not all_objects:
+                return [], None
+            # If every value in the dict is fully multimodal, exclude the entire field
+            if len(exclude) == len(obj) and all(v is True for v in exclude.values()):
+                return all_objects, True
+            return all_objects, exclude
+
+        return [], None
+
     def copy(self) -> "ChatHistory":
         """
         Creates a copy of the chat history.

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/atomic-agents/atomic_agents/utils/token_counter.py

@@ -147,12 +147,15 @@ class TokenCounter:
             raise TypeError(f"model must be a string, got {type(model).__name__}")
 
         try:
-            from litellm import get_max_tokens
+            from litellm import get_model_info
         except ImportError as e:
             raise ImportError("litellm is required for token counting. " "Install it with: pip install litellm") from e
 
         try:
-            return get_max_tokens(model)
+            info = get_model_info(model)
+            # Use max_input_tokens (context window) not max_tokens (output limit)
+            max_input = info.get("max_input_tokens")
+            return max_input if max_input is not None else info.get("max_tokens")
         except Exception as e:
             logger.warning(f"Could not determine max tokens for model '{model}': {e}")
             return None

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/atomic-agents/tests/connectors/mcp/test_mcp_factory.py

@@ -207,9 +207,7 @@ async def test_typed_output_schema_with_structured_content_dict(monkeypatch):
         "required": ["results", "count"],
     }
     definitions = [
-        MCPToolDefinition(
-            name="SearchTool", description="Search tool", input_schema=input_schema, output_schema=output_schema
-        )
+        MCPToolDefinition(name="SearchTool", description="Search tool", input_schema=input_schema, output_schema=output_schema)
     ]
     monkeypatch.setattr(MCPFactory, "_fetch_tool_definitions", lambda self: definitions)
     tools = fetch_mcp_tools("http://example.com", MCPTransportType.HTTP_STREAM)

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/atomic-agents/tests/connectors/mcp/test_schema_transformer.py

@@ -218,9 +218,7 @@ class TestCreateModelFromSchema:
             },
             "required": ["results", "count"],
         }
-        model = SchemaTransformer.create_model_from_schema(
-            schema, "OutputModel", "my_tool", is_output_schema=True
-        )
+        model = SchemaTransformer.create_model_from_schema(schema, "OutputModel", "my_tool", is_output_schema=True)
 
         # Output schema should NOT have tool_name field
         assert "tool_name" not in model.model_fields
@@ -243,9 +241,7 @@ class TestCreateModelFromSchema:
             },
             "required": ["query"],
         }
-        model = SchemaTransformer.create_model_from_schema(
-            schema, "InputModel", "my_tool", is_output_schema=False
-        )
+        model = SchemaTransformer.create_model_from_schema(schema, "InputModel", "my_tool", is_output_schema=False)
 
         # Input schema SHOULD have tool_name field
         assert "tool_name" in model.model_fields
@@ -271,9 +267,7 @@ class TestCreateModelFromSchema:
 
         # Output schema for resource - should not have resource_name
         model = SchemaTransformer.create_model_from_schema(
-            schema, "ResourceOutput", "my_resource",
-            attribute_type=MCPAttributeType.RESOURCE,
-            is_output_schema=True
+            schema, "ResourceOutput", "my_resource", attribute_type=MCPAttributeType.RESOURCE, is_output_schema=True
         )
 
         assert "resource_name" not in model.model_fields

{atomic_agents-2.6.0 → atomic_agents-2.7.3}/atomic-agents/tests/context/test_chat_history.py

@@ -538,3 +538,330 @@ def test_process_multimodal_paths_comprehensive():
     assert loaded_content.images[0].source == Path("test/sample.jpg")
     assert isinstance(loaded_content.pdfs[0].source, Path)
     assert loaded_content.pdfs[0].source == Path("test/doc.pdf")
+
+
+def test_get_history_nested_pydantic_with_toplevel_multimodal(history):
+    """Issue #208: nested Pydantic model + top-level multimodal causes json.dumps TypeError"""
+
+    class ContextInfo(BaseIOSchema):
+        """Nested context info."""
+
+        label: str = Field(..., description="Label")
+        value: str = Field(..., description="Value")
+
+    class AgentInput(BaseIOSchema):
+        """Input with multimodal and nested schema."""
+
+        instruction: str = Field(..., description="Instruction text")
+        images: List[instructor.Image] = Field(..., description="Images")
+        context: ContextInfo = Field(..., description="Nested context")
+
+    mock_image = instructor.Image(source="test_url", media_type="image/jpeg", detail="low")
+    context = ContextInfo(label="example", value="nested")
+    content = AgentInput(instruction="Do something", images=[mock_image], context=context)
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert result[0]["role"] == "user"
+    assert isinstance(result[0]["content"], list)
+
+    json_part = json.loads(result[0]["content"][0])
+    assert json_part["instruction"] == "Do something"
+    assert json_part["context"] == {"label": "example", "value": "nested"}
+    assert "images" not in json_part
+    assert result[0]["content"][1] == mock_image
+
+
+def test_get_history_deeply_nested_multimodal_only(history):
+    """Issue #141: multimodal inside nested schema with no top-level multimodal"""
+
+    class Document(BaseIOSchema):
+        """PDF document with owner."""
+
+        pdf: instructor.multimodal.PDF = Field(..., description="The PDF data")
+        owner: str = Field(..., description="The PDF owner")
+
+    class InputSchema(BaseIOSchema):
+        """A list of documents to analyze."""
+
+        documents: List[Document] = Field(..., description="List of documents")
+        instruction: str = Field(..., description="What to do")
+
+    mock_pdf = instructor.multimodal.PDF(source="test_pdf_url", media_type="application/pdf", detail="low")
+    content = InputSchema(
+        documents=[Document(pdf=mock_pdf, owner="Alice")],
+        instruction="Analyze these",
+    )
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert isinstance(result[0]["content"], list)
+
+    json_part = json.loads(result[0]["content"][0])
+    assert json_part["instruction"] == "Analyze these"
+    assert json_part["documents"] == [{"owner": "Alice"}]
+    assert result[0]["content"][1] == mock_pdf
+
+
+def test_get_history_mixed_nested_and_toplevel_multimodal(history):
+    """Both nested and top-level multimodal content"""
+
+    class Attachment(BaseIOSchema):
+        """An attachment with an image."""
+
+        image: instructor.Image = Field(..., description="Attached image")
+        caption: str = Field(..., description="Caption")
+
+    class MessageInput(BaseIOSchema):
+        """Message with both nested and top-level multimodal."""
+
+        text: str = Field(..., description="Message text")
+        inline_image: instructor.Image = Field(..., description="Inline image")
+        attachment: Attachment = Field(..., description="An attachment")
+
+    img1 = instructor.Image(source="inline_url", media_type="image/jpeg", detail="low")
+    img2 = instructor.Image(source="attached_url", media_type="image/png", detail="low")
+    content = MessageInput(
+        text="Check this out",
+        inline_image=img1,
+        attachment=Attachment(image=img2, caption="See here"),
+    )
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert isinstance(result[0]["content"], list)
+
+    assert len(result[0]["content"]) == 3  # JSON + 2 images
+    json_part = json.loads(result[0]["content"][0])
+    assert json_part["text"] == "Check this out"
+    assert json_part["attachment"] == {"caption": "See here"}
+    assert "inline_image" not in json_part
+    assert img1 in result[0]["content"]
+    assert img2 in result[0]["content"]
+
+
+def test_get_history_list_of_nested_schemas_with_multimodal(history):
+    """Multiple nested schemas each containing multimodal objects"""
+
+    class Document(BaseIOSchema):
+        """A document with PDF."""
+
+        pdf: instructor.multimodal.PDF = Field(..., description="The PDF")
+        title: str = Field(..., description="Document title")
+
+    class BatchInput(BaseIOSchema):
+        """Batch of documents."""
+
+        documents: List[Document] = Field(..., description="Documents to process")
+
+    pdf1 = instructor.multimodal.PDF(source="doc1.pdf", media_type="application/pdf", detail="low")
+    pdf2 = instructor.multimodal.PDF(source="doc2.pdf", media_type="application/pdf", detail="low")
+    content = BatchInput(
+        documents=[
+            Document(pdf=pdf1, title="First"),
+            Document(pdf=pdf2, title="Second"),
+        ]
+    )
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert isinstance(result[0]["content"], list)
+
+    assert len(result[0]["content"]) == 3  # JSON + 2 PDFs
+    json_part = json.loads(result[0]["content"][0])
+    assert json_part["documents"] == [{"title": "First"}, {"title": "Second"}]
+    assert pdf1 in result[0]["content"]
+    assert pdf2 in result[0]["content"]
+
+
+def test_get_history_only_multimodal_fields(history):
+    """Schema where ALL fields are multimodal - JSON should be omitted"""
+
+    class ImagesOnly(BaseIOSchema):
+        """Only images."""
+
+        images: List[instructor.Image] = Field(..., description="Images")
+
+    img1 = instructor.Image(source="url1", media_type="image/jpeg", detail="low")
+    img2 = instructor.Image(source="url2", media_type="image/jpeg", detail="low")
+    content = ImagesOnly(images=[img1, img2])
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert isinstance(result[0]["content"], list)
+    # No JSON string should be present since all fields are multimodal
+    assert len(result[0]["content"]) == 2
+    assert all(not isinstance(item, str) for item in result[0]["content"])
+    assert img1 in result[0]["content"]
+    assert img2 in result[0]["content"]
+
+
+def test_get_history_no_multimodal_unchanged(history):
+    """Non-multimodal schemas should work exactly as before"""
+
+    class SimpleInput(BaseIOSchema):
+        """Simple input."""
+
+        text: str = Field(..., description="Text")
+        count: int = Field(..., description="Count")
+
+    content = SimpleInput(text="hello", count=42)
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert result[0]["role"] == "user"
+    assert isinstance(result[0]["content"], str)
+    assert json.loads(result[0]["content"]) == {"text": "hello", "count": 42}
+
+
+# ---------------------------------------------------------------------------
+# Direct unit tests for _extract_multimodal_info
+# ---------------------------------------------------------------------------
+
+
+def test_extract_multimodal_info_plain_schema():
+    """No multimodal content returns empty list and None exclude spec"""
+
+    class Plain(BaseIOSchema):
+        """Plain schema."""
+
+        text: str = Field(..., description="Text")
+
+    objs, spec = ChatHistory._extract_multimodal_info(Plain(text="hello"))
+    assert objs == []
+    assert spec is None
+
+
+def test_extract_multimodal_info_toplevel_image():
+    """Top-level Image returns the object and True exclude spec"""
+    img = instructor.Image(source="url", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info(img)
+    assert objs == [img]
+    assert spec is True
+
+
+def test_extract_multimodal_info_nested_schema():
+    """Nested schema with multimodal returns correct exclude spec shape"""
+
+    class Inner(BaseIOSchema):
+        """Inner schema."""
+
+        image: instructor.Image = Field(..., description="Image")
+        label: str = Field(..., description="Label")
+
+    class Outer(BaseIOSchema):
+        """Outer schema."""
+
+        inner: Inner = Field(..., description="Inner")
+        text: str = Field(..., description="Text")
+
+    img = instructor.Image(source="url", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info(Outer(inner=Inner(image=img, label="test"), text="hello"))
+
+    assert objs == [img]
+    # Exclude spec should be {"inner": {"image": True}}
+    assert spec == {"inner": {"image": True}}
+
+
+def test_extract_multimodal_info_list_all_multimodal():
+    """List where every item is multimodal collapses to True"""
+
+    class Schema(BaseIOSchema):
+        """Schema with all-multimodal list."""
+
+        images: List[instructor.Image] = Field(..., description="Images")
+
+    img1 = instructor.Image(source="url1", media_type="image/jpeg", detail="low")
+    img2 = instructor.Image(source="url2", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info(Schema(images=[img1, img2]))
+
+    assert objs == [img1, img2]
+    # All items multimodal → field excluded entirely
+    assert spec == {"images": True}
+
+
+def test_extract_multimodal_info_list_partial_multimodal():
+    """List with mixed content returns index-based exclude spec"""
+
+    class Schema(BaseIOSchema):
+        """Schema with mixed list."""
+
+        items: List[Union[str, instructor.Image]] = Field(..., description="Items")
+
+    img = instructor.Image(source="url", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info(Schema(items=["text", img]))
+
+    assert objs == [img]
+    # Only index 1 is multimodal
+    assert spec == {"items": {1: True}}
+
+
+def test_extract_multimodal_info_tuple_support():
+    """Tuples are handled identically to lists"""
+    img = instructor.Image(source="url", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info((img, "text"))
+    assert objs == [img]
+    assert spec == {0: True}
+
+
+def test_extract_multimodal_info_dict_with_multimodal():
+    """Dict values containing multimodal objects return correct exclude spec"""
+    img = instructor.Image(source="url", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info({"key1": img, "key2": "text"})
+
+    assert objs == [img]
+    assert spec == {"key1": True}
+
+
+def test_extract_multimodal_info_dict_all_multimodal():
+    """Dict where all values are multimodal collapses to True"""
+    img1 = instructor.Image(source="url1", media_type="image/jpeg", detail="low")
+    img2 = instructor.Image(source="url2", media_type="image/jpeg", detail="low")
+    objs, spec = ChatHistory._extract_multimodal_info({"a": img1, "b": img2})
+
+    assert objs == [img1, img2]
+    assert spec is True
+
+
+def test_extract_multimodal_info_dict_no_multimodal():
+    """Dict with no multimodal returns empty list and None"""
+    objs, spec = ChatHistory._extract_multimodal_info({"key1": "text", "key2": 42})
+    assert objs == []
+    assert spec is None
+
+
+def test_get_history_dict_of_images(history):
+    """Dict[str, Image] field exercises the dict code path in get_history"""
+
+    class DictImageSchema(BaseIOSchema):
+        """Schema with dict of images."""
+
+        image_map: Dict[str, instructor.Image] = Field(..., description="Named images")
+        note: str = Field(..., description="A note")
+
+    img_a = instructor.Image(source="url_a", media_type="image/jpeg", detail="low")
+    img_b = instructor.Image(source="url_b", media_type="image/jpeg", detail="low")
+    content = DictImageSchema(image_map={"front": img_a, "back": img_b}, note="Two views")
+
+    history.add_message("user", content)
+    result = history.get_history()
+
+    assert len(result) == 1
+    assert isinstance(result[0]["content"], list)
+    assert len(result[0]["content"]) == 3  # JSON + 2 images
+    json_part = json.loads(result[0]["content"][0])
+    assert json_part["note"] == "Two views"
+    assert "image_map" not in json_part
+    assert img_a in result[0]["content"]
+    assert img_b in result[0]["content"]