agent-framework-core 1.18.0__tar.gz → 1.19.0__tar.gz

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-core
-Version: 1.18.0
+Version: 1.19.0
 Summary: Microsoft Agent Framework for building AI Agents with Python. This is the core package that has all the core abstractions and implementations.
 Author-email: Microsoft <af-support@microsoft.com>
 Requires-Python: >=3.10
@@ -21,6 +21,7 @@ Requires-Dist: typing-extensions>=4.15.0,<5
 Requires-Dist: pydantic>=2,<3
 Requires-Dist: python-dotenv>=1,<2
 Requires-Dist: opentelemetry-api>=1.39.0,<2
+Requires-Dist: pyyaml>=6.0,<7.0
 Requires-Dist: mcp>=1.24.0,<2 ; extra == "all"
 Requires-Dist: agent-framework-a2a ; extra == "all"
 Requires-Dist: agent-framework-ag-ui ; extra == "all"
@@ -41,7 +42,7 @@ Requires-Dist: agent-framework-foundry-hosting ; extra == "all"
 Requires-Dist: agent-framework-foundry-local ; extra == "all"
 Requires-Dist: agent-framework-gemini ; extra == "all"
 Requires-Dist: agent-framework-github-copilot ; extra == "all" and ( python_version >= '3.11')
-Requires-Dist: agent-framework-hyperlight ; extra == "all" and ( (sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and platform_machine == 'AMD64'))
+Requires-Dist: agent-framework-hyperlight ; extra == "all" and ( python_version < '3.15' and ((sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and platform_machine == 'AMD64')))
 Requires-Dist: agent-framework-mem0 ; extra == "all"
 Requires-Dist: agent-framework-mistral ; extra == "all"
 Requires-Dist: agent-framework-monty ; extra == "all"
@@ -227,6 +228,21 @@ asyncio.run(main())
 
 You can explore additional agent samples [here](https://github.com/microsoft/agent-framework/tree/main/python/samples/02-agents).
 
+### MCP HTTP client ownership and cookies
+
+**Breaking change:** HTTP clients created by `MCPStreamableHTTPTool` no longer persist
+response cookies. This applies with or without a `header_provider`, including repeated
+calls within the same MCP session. Connection reuse, timeout and redirect defaults,
+and cleanup on close or reset are preserved. Explicit `Cookie` headers supplied through
+`static_headers` or a `header_provider` are still supported.
+
+Applications relying on cookie-based authentication, sessions, or load-balancer affinity
+must supply an `httpx.AsyncClient` through `http_client=`. Supplied clients retain their
+configuration and response-cookie handling and must be closed by the caller. Scope
+cookie-bearing clients and MCP tool sessions to one authenticated principal; do not
+share a user-specific cookie jar across users. Rejecting cookies does not partition
+MCP protocol sessions or other server-side state between principals.
+
 ## 5. Multi-Agent Orchestration
 
 Coordinate multiple agents to collaborate on complex tasks using orchestration patterns:

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/README.md

@@ -168,6 +168,21 @@ asyncio.run(main())
 
 You can explore additional agent samples [here](https://github.com/microsoft/agent-framework/tree/main/python/samples/02-agents).
 
+### MCP HTTP client ownership and cookies
+
+**Breaking change:** HTTP clients created by `MCPStreamableHTTPTool` no longer persist
+response cookies. This applies with or without a `header_provider`, including repeated
+calls within the same MCP session. Connection reuse, timeout and redirect defaults,
+and cleanup on close or reset are preserved. Explicit `Cookie` headers supplied through
+`static_headers` or a `header_provider` are still supported.
+
+Applications relying on cookie-based authentication, sessions, or load-balancer affinity
+must supply an `httpx.AsyncClient` through `http_client=`. Supplied clients retain their
+configuration and response-cookie handling and must be closed by the caller. Scope
+cookie-bearing clients and MCP tool sessions to one authenticated principal; do not
+share a user-specific cookie jar across users. Rejecting cookies does not partition
+MCP protocol sessions or other server-side state between principals.
+
 ## 5. Multi-Agent Orchestration
 
 Coordinate multiple agents to collaborate on complex tasks using orchestration patterns:

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/agent_framework/__init__.py

@@ -33,6 +33,7 @@ from ._telemetry import (
 from .exceptions import (
     AgentFrameworkException,
     MiddlewareException,
+    ResponseInvalidatedException,
     UserInputRequiredException,
     WorkflowCheckpointException,
     WorkflowConvergenceException,
@@ -309,8 +310,13 @@ _LAZY_MODULE_EXPORTS: Final[Mapping[str, tuple[str, ...]]] = {
         "SearchType",
         "SupportsVectorSearch",
         "SupportsVectorUpsert",
+        "VectorCollectionContextProvider",
         "VectorStoreCollectionDefinition",
         "VectorStoreField",
+        "VectorStoreHistoryProvider",
+        "create_delete_tool",
+        "create_get_tool",
+        "create_upsert_tool",
         "create_vector_search_tool",
         "register_vectorstoremodel",
         "vectorstoremodel",
@@ -565,6 +571,7 @@ __all__ = [
     "Param",
     "RawAgent",
     "ReleaseCandidateFeature",
+    "ResponseInvalidatedException",
     "ResponseStream",
     "Role",
     "RoleLiteral",
@@ -631,8 +638,10 @@ __all__ = [
     "UsageDetails",
     "UserInputRequiredException",
     "ValidationTypeEnum",
+    "VectorCollectionContextProvider",
     "VectorStoreCollectionDefinition",
     "VectorStoreField",
+    "VectorStoreHistoryProvider",
     "Workflow",
     "WorkflowAgent",
     "WorkflowBuilder",
@@ -665,8 +674,11 @@ __all__ = [
     "create_agent_hooks_middleware_from_emitter",
     "create_always_approve_tool_response",
     "create_always_approve_tool_with_arguments_response",
+    "create_delete_tool",
     "create_edge_runner",
+    "create_get_tool",
     "create_harness_agent",
+    "create_upsert_tool",
     "create_vector_search_tool",
     "detect_media_type_from_base64",
     "enqueue_messages",

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/agent_framework/__init__.pyi

@@ -266,8 +266,13 @@ from ._vectors import (
     SearchType,
     SupportsVectorSearch,
     SupportsVectorUpsert,
+    VectorCollectionContextProvider,
     VectorStoreCollectionDefinition,
     VectorStoreField,
+    VectorStoreHistoryProvider,
+    create_delete_tool,
+    create_get_tool,
+    create_upsert_tool,
     create_vector_search_tool,
     register_vectorstoremodel,
     vectorstoremodel,
@@ -335,6 +340,7 @@ from ._workflows._workflow_executor import SubWorkflowRequestMessage, SubWorkflo
 from .exceptions import (
     AgentFrameworkException,
     MiddlewareException,
+    ResponseInvalidatedException,
     UserInputRequiredException,
     WorkflowCheckpointException,
     WorkflowConvergenceException,
@@ -520,6 +526,7 @@ __all__ = [
     "Param",
     "RawAgent",
     "ReleaseCandidateFeature",
+    "ResponseInvalidatedException",
     "ResponseStream",
     "Role",
     "RoleLiteral",
@@ -586,8 +593,10 @@ __all__ = [
     "UsageDetails",
     "UserInputRequiredException",
     "ValidationTypeEnum",
+    "VectorCollectionContextProvider",
     "VectorStoreCollectionDefinition",
     "VectorStoreField",
+    "VectorStoreHistoryProvider",
     "Workflow",
     "WorkflowAgent",
     "WorkflowBuilder",
@@ -620,8 +629,11 @@ __all__ = [
     "create_agent_hooks_middleware_from_emitter",
     "create_always_approve_tool_response",
     "create_always_approve_tool_with_arguments_response",
+    "create_delete_tool",
     "create_edge_runner",
+    "create_get_tool",
     "create_harness_agent",
+    "create_upsert_tool",
     "create_vector_search_tool",
     "detect_media_type_from_base64",
     "enqueue_messages",

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/agent_framework/_agents.py

@@ -1405,8 +1405,10 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
             self.context_providers.append(InMemoryHistoryProvider())
 
         active_session = session
+        framework_created_session = False
         if active_session is None and self.context_providers:
             active_session = AgentSession()
+            framework_created_session = True
 
         per_service_call_history_providers = self._resolve_per_service_call_history_providers(
             session=active_session,
@@ -1455,12 +1457,22 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
         # Normalize tools
         normalized_tools = _normalize_tools(tools_)
 
+        # Extract additional function arguments
+        effective_function_invocation_kwargs = (
+            dict(function_invocation_kwargs) if function_invocation_kwargs is not None else {}
+        )
+        additional_function_arguments = {**effective_function_invocation_kwargs, **existing_additional_args}
+
         # Resolve final tool list (configured tools + runtime provided tools + local MCP server tools)
         final_tools = list(base_tools)
         for tool in normalized_tools:
             if isinstance(tool, MCPTool):
+                await tool._prepare_for_run(additional_function_arguments)  # pyright: ignore[reportPrivateUsage]
                 if not tool.is_connected:
+                    # The handshake and discovery requests are issued before any tool call, so the run's
+                    # kwargs must reach header_provider here or those requests go out unauthenticated.
                     await self._async_exit_stack.enter_async_context(tool)
+                    await tool._prepare_for_run(additional_function_arguments)  # pyright: ignore[reportPrivateUsage]
                 _append_unique_tools(
                     final_tools,
                     tool.functions,
@@ -1470,19 +1482,18 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
                 _append_unique_tools(final_tools, [tool])
 
         for mcp_server in self.mcp_tools:
+            await mcp_server._prepare_for_run(additional_function_arguments)  # pyright: ignore[reportPrivateUsage]
             if not mcp_server.is_connected:
                 await self._async_exit_stack.enter_async_context(mcp_server)
+                await mcp_server._prepare_for_run(  # pyright: ignore[reportPrivateUsage]
+                    additional_function_arguments
+                )
             _append_unique_tools(
                 final_tools,
                 mcp_server.functions,
                 duplicate_error_message=mcp_duplicate_message,
             )
 
-        effective_function_invocation_kwargs = (
-            dict(function_invocation_kwargs) if function_invocation_kwargs is not None else {}
-        )
-        additional_function_arguments = {**effective_function_invocation_kwargs, **existing_additional_args}
-
         model = opts.pop("model", None)
 
         # Build options dict from run() options merged with provided options
@@ -1520,8 +1531,12 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
         session_messages: list[Message] = session_context.get_messages(include_input=True)
 
         effective_client_kwargs = dict(client_kwargs) if client_kwargs is not None else {}
+        from ._tools import _APPROVAL_SESSION_IS_AUTHORITATIVE_KEY  # pyright: ignore[reportPrivateUsage]
+
+        effective_client_kwargs.pop(_APPROVAL_SESSION_IS_AUTHORITATIVE_KEY, None)
         if active_session is not None:
             effective_client_kwargs["session"] = active_session
+            effective_client_kwargs[_APPROVAL_SESSION_IS_AUTHORITATIVE_KEY] = not framework_created_session
         per_service_call_history_middleware: PerServiceCallHistoryPersistingMiddleware | None = None
         if per_service_call_history_providers and active_session is not None:
             per_service_call_history_middleware = PerServiceCallHistoryPersistingMiddleware(
@@ -1712,7 +1727,7 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
                     logger.error("Failed to send log message to server: %s", e)
 
         @server.list_tools()
-        async def _list_tools() -> list[types.Tool]:  # type: ignore
+        async def _list_tools() -> list[types.Tool]:
             """List all tools in the agent."""
             schema = agent_tool.parameters()
 
@@ -1726,7 +1741,7 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
             return [tool]
 
         @server.call_tool()
-        async def _call_tool(  # type: ignore
+        async def _call_tool(
             name: str, arguments: dict[str, Any]
         ) -> Sequence[types.TextContent | types.ImageContent | types.AudioContent | types.EmbeddedResource]:
             """Call a tool in the agent."""
@@ -1769,7 +1784,7 @@ class RawAgent(BaseAgent, Generic[OptionsCoT]):
             return mcp_content or [types.TextContent(type="text", text="")]
 
         @server.set_logging_level()
-        async def _set_logging_level(level: types.LoggingLevel) -> None:  # type: ignore
+        async def _set_logging_level(level: types.LoggingLevel) -> None:
             """Set the logging level for the server."""
             logger.setLevel(LOG_LEVEL_MAPPING[level])
             # emit this log with the new minimum level

{agent_framework_core-1.18.0 → agent_framework_core-1.19.0}/agent_framework/_compaction.py

@@ -30,6 +30,12 @@ GROUP_KIND_KEY = "kind"
 GROUP_INDEX_KEY = "index"
 GROUP_HAS_REASONING_KEY = "has_reasoning"
 GROUP_TOKEN_COUNT_KEY = "token_count"  # ruff:ignore[hardcoded-password-string] # nosec B105 - compaction metadata key, not a credential
+GROUP_TOKEN_COUNT_BASIS_KEY = "token_count_basis"  # ruff:ignore[hardcoded-password-string] # nosec B105 - compaction metadata key, not a credential
+# Bumped whenever the token-estimation serialization changes. Cached counts
+# stamped with an older basis are recomputed instead of reused: annotations
+# survive Message.to_dict()/from_dict() round-trips, so without the basis a
+# transcript annotated before a serialization change keeps its stale counts.
+TOKEN_COUNT_BASIS_VERSION = 2
 EXCLUDED_KEY = "_excluded"
 EXCLUDE_REASON_KEY = "_exclude_reason"
 SUMMARY_OF_MESSAGE_IDS_KEY = "_summary_of_message_ids"
@@ -48,6 +54,44 @@ _TOOL_CALL_CONTENT_TYPES: Final[set[str]] = {
 }
 
 
+def _deduplicate_origin_session_ids(origin_session_ids: Iterable[str]) -> list[str]:
+    """Return origin session IDs in first-seen order without duplicates."""
+    unique_origin_session_ids: list[str] = []
+    seen_origin_session_ids: set[str] = set()
+    for origin_session_id in origin_session_ids:
+        if origin_session_id not in seen_origin_session_ids:
+            seen_origin_session_ids.add(origin_session_id)
+            unique_origin_session_ids.append(origin_session_id)
+    return unique_origin_session_ids
+
+
+def _aggregate_origin_session_ids(messages: Sequence[Message]) -> list[str]:
+    """Aggregate origin_session_ids from a sequence of Message objects.
+
+    Extracts origin_session_ids from each message's _attribution and returns
+    a deduplicated list preserving first-seen order. Messages without attribution
+    or without origin_session_ids are silently skipped.
+
+    Args:
+        messages: The Message objects to aggregate provenance from.
+
+    Returns:
+        Deduplicated origin_session_ids in first-seen order.
+    """
+    origin_session_ids: list[str] = []
+    for message in messages:
+        attribution = message.additional_properties.get("_attribution")
+        if not isinstance(attribution, Mapping):
+            continue
+        origins = attribution.get("origin_session_ids")  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        if not isinstance(origins, Sequence) or isinstance(origins, str):
+            continue
+        for origin in cast("Sequence[Any]", origins):
+            if isinstance(origin, str):
+                origin_session_ids.append(origin)
+    return _deduplicate_origin_session_ids(origin_session_ids)
+
+
 @runtime_checkable
 class TokenizerProtocol(Protocol):
     """Protocol for token counters used by token-aware compaction strategies."""
@@ -378,13 +422,13 @@ def _set_group_summarized_by_summary_id(message: Message, summary_id: str) -> No
 def _reconcile_compaction_summaries(  # pyright: ignore[reportUnusedFunction]
     source_messages: list[Message],
     working_messages: Sequence[Message],
-    previous_message_ids: set[int],
+    source_message_identities: set[int],
 ) -> None:
-    """Reconcile summaries of source messages without persisting unrelated rewrites."""
+    """Reconcile summaries supported by source-owned messages without persisting unrelated rewrites."""
     source_message_ids = {message.message_id for message in source_messages if message.message_id}
     candidates: list[tuple[Message, set[str]]] = []
     for message in working_messages:
-        if id(message) in previous_message_ids:
+        if id(message) in source_message_identities:
             continue
 
         annotation = _read_group_annotation_raw(message)
@@ -458,7 +502,13 @@ def _write_group_annotation(
     token_count: int | None = None
     if existing_raw_annotation is not None:
         raw_token_count = existing_raw_annotation.get(GROUP_TOKEN_COUNT_KEY)
-        if isinstance(raw_token_count, int) or raw_token_count is None:
+        raw_token_count_basis = existing_raw_annotation.get(GROUP_TOKEN_COUNT_BASIS_KEY)
+        # Preserve a cached count only when it was computed with the current
+        # serialization basis; counts from older bases are stale and get
+        # recomputed (see TOKEN_COUNT_BASIS_VERSION).
+        if raw_token_count_basis == TOKEN_COUNT_BASIS_VERSION and (
+            isinstance(raw_token_count, int) or raw_token_count is None
+        ):
             token_count = raw_token_count
         unknown_fields = {
             key: value
@@ -470,6 +520,7 @@ def _write_group_annotation(
                 GROUP_INDEX_KEY,
                 GROUP_HAS_REASONING_KEY,
                 GROUP_TOKEN_COUNT_KEY,
+                GROUP_TOKEN_COUNT_BASIS_KEY,
             }
         }
 
@@ -479,6 +530,7 @@ def _write_group_annotation(
         GROUP_INDEX_KEY: index,
         GROUP_HAS_REASONING_KEY: has_reasoning,
         GROUP_TOKEN_COUNT_KEY: token_count,
+        GROUP_TOKEN_COUNT_BASIS_KEY: TOKEN_COUNT_BASIS_VERSION if token_count is not None else None,
     }
     annotation.update(unknown_fields)
     message.additional_properties[GROUP_ANNOTATION_KEY] = annotation
@@ -512,6 +564,10 @@ def _token_count(message: Message) -> int | None:
     if annotation is None:
         return None
     token_count = annotation.get(GROUP_TOKEN_COUNT_KEY)
+    # Counts stamped with an older serialization basis are stale: they were
+    # computed from a different serialized form and must be recomputed.
+    if annotation.get(GROUP_TOKEN_COUNT_BASIS_KEY) != TOKEN_COUNT_BASIS_VERSION:
+        return None
     return token_count if isinstance(token_count, int) else None
 
 
@@ -520,6 +576,7 @@ def _write_token_count(message: Message, token_count: int) -> None:
     if annotation is None:
         return
     annotation[GROUP_TOKEN_COUNT_KEY] = token_count
+    annotation[GROUP_TOKEN_COUNT_BASIS_KEY] = TOKEN_COUNT_BASIS_VERSION
     message.additional_properties[GROUP_ANNOTATION_KEY] = annotation
 
 
@@ -694,12 +751,68 @@ def annotate_message_groups(
     return _ordered_group_ids_from_annotations(messages)
 
 
+_OPAQUE_REASONING_KEYS: Final[frozenset[str]] = frozenset({"encrypted_content"})
+
+
+def _strip_opaque_reasoning_payload(value: Any) -> Any:
+    """Recursively drop opaque reasoning members, keeping clear-text payloads."""
+    if isinstance(value, dict):
+        entries = cast("dict[Any, Any]", value)
+        filtered: dict[Any, Any] = {}
+        for key, item in entries.items():
+            if key in _OPAQUE_REASONING_KEYS:
+                continue
+            stripped = _strip_opaque_reasoning_payload(item)
+            if stripped is not None:
+                filtered[key] = stripped
+        return filtered or None
+    if isinstance(value, list):
+        entries = cast("list[Any]", value)
+        kept = [
+            stripped
+            for stripped in (_strip_opaque_reasoning_payload(entry) for entry in entries)
+            if stripped is not None
+        ]
+        return kept or None
+    return value
+
+
 def _serialize_content(content: Content) -> dict[str, Any]:
     payload = content.to_dict(exclude_none=True)
     payload.pop("raw_representation", None)
     # ``items`` mirrors ``result`` for function_result content; exclude it
     # to avoid double-counting tokens during estimation.
     payload.pop("items", None)
+    # ``protected_data`` carries provider reasoning payloads. JSON-serialised
+    # reasoning_details (Chat Completions) are replayed to the provider as
+    # clear text -- ``summary``, ``reasoning_text`` and nested ``reasoning.text``
+    # are part of the context the provider receives, so only their opaque
+    # members (``encrypted_content``) are excluded and the clear text stays
+    # counted. Anything that is not such a JSON structure (Anthropic thinking
+    # ``signature``, Responses API ``encrypted_content`` blobs) is replayed
+    # opaquely and never tokenised; exclude it so estimation measures the text
+    # the model actually sees.
+    protected_data = payload.get("protected_data")
+    if isinstance(protected_data, str) and protected_data:
+        try:
+            reasoning_payload = json.loads(protected_data)
+        except ValueError:
+            reasoning_payload = None
+        filtered = (
+            _strip_opaque_reasoning_payload(reasoning_payload) if isinstance(reasoning_payload, (dict, list)) else None
+        )
+        if filtered is None:
+            payload.pop("protected_data", None)
+        else:
+            payload["protected_data"] = json.dumps(filtered, ensure_ascii=False)
+    else:
+        payload.pop("protected_data", None)
+    additional_properties = payload.get("additional_properties")
+    if isinstance(additional_properties, dict) and "encrypted_content" in additional_properties:
+        typed_properties = cast("dict[str, Any]", additional_properties)
+        payload["additional_properties"] = {
+            key: value for key, value in typed_properties.items() if key != "encrypted_content"
+        }
     return payload
 
 
@@ -1142,19 +1255,28 @@ class ToolResultCompactionStrategy:
                 _set_group_summarized_by_summary_id(msg, summary_id)
                 changed = set_excluded(msg, excluded=True, reason="tool_result_compaction") or changed
 
+            # Aggregate provenance directly from the actual Message objects being summarized
+            # This ensures origin_session_ids are preserved even when message_id is None
+            aggregated_origins = _aggregate_origin_session_ids(group_msgs)
+
             # Insert summary with forward links to the originals.
             summary_annotation = {
                 SUMMARY_OF_MESSAGE_IDS_KEY: original_message_ids,
                 SUMMARY_OF_GROUP_IDS_KEY: [group_id],
             }
             insertion_index = starts.get(group_id, 0)
+
+            summary_additional_properties: dict[str, Any] = {
+                GROUP_ANNOTATION_KEY: summary_annotation,
+            }
+            if aggregated_origins:
+                summary_additional_properties["_attribution"] = {"origin_session_ids": aggregated_origins}
+
             summary_message = Message(
                 role="assistant",
                 contents=[summary_text],
                 message_id=summary_id,
-                additional_properties={
-                    GROUP_ANNOTATION_KEY: summary_annotation,
-                },
+                additional_properties=summary_additional_properties,
             )
             messages.insert(insertion_index, summary_message)
             annotate_message_groups(messages, from_index=insertion_index, force_reannotate=False)
@@ -1273,8 +1395,8 @@ def _format_summary_content(content: Content) -> str:
         result_text = _format_summary_result_items(content.items) if content.items else ""
         if not result_text:
             result_text = _tool_result_text(content.result) if content.result is not None else "no result"
-        if content.exception:
-            result_text = f"error({content.exception}): {result_text}"
+        if content.exception is not None:
+            result_text = f"error: {result_text}"
         call_id_suffix = f" [call_id={content.call_id}]" if content.call_id else ""
         return f"function_result: {result_text}{call_id_suffix}"
     if content.type == "mcp_server_tool_call":
@@ -1285,8 +1407,8 @@ def _format_summary_content(content: Content) -> str:
         return call
     if content.type == "mcp_server_tool_result":
         result_text = _tool_result_text(content.output)
-        if content.exception:
-            result_text = f"error({content.exception}): {result_text}"
+        if content.exception is not None:
+            result_text = f"error: {result_text}"
         call_id_suffix = f" [call_id={content.call_id}]" if content.call_id else ""
         return f"mcp_tool_result: {result_text}{call_id_suffix}"
     if content.type in ("function_approval_request", "function_approval_response"):
@@ -1570,13 +1692,21 @@ class SummarizationStrategy:
             SUMMARY_OF_GROUP_IDS_KEY: summary_of_group_ids,
         }
 
+        # Aggregate provenance directly from the actual Message objects being summarized
+        # This ensures origin_session_ids are preserved even when message_id is None
+        aggregated_origins = _aggregate_origin_session_ids(messages_to_summarize)
+
+        summary_additional_properties: dict[str, Any] = {
+            GROUP_ANNOTATION_KEY: summary_annotation,
+        }
+        if aggregated_origins:
+            summary_additional_properties["_attribution"] = {"origin_session_ids": aggregated_origins}
+
         summary_message = Message(
             role="assistant",
             contents=[summary_text],
             message_id=summary_id,
-            additional_properties={
-                GROUP_ANNOTATION_KEY: summary_annotation,
-            },
+            additional_properties=summary_additional_properties,
         )
 
         for message in messages_to_summarize:
@@ -1817,6 +1947,11 @@ class CompactionProvider(ContextProvider):
         if not all_messages:
             return
 
+        # Track each original message's source before compaction
+        source_by_id: dict[int, str] = {
+            id(message): sid for sid, msgs in context.context_messages.items() for message in msgs
+        }
+
         await _run_compaction_strategy(
             all_messages,
             strategy=self.before_strategy,
@@ -1825,9 +1960,23 @@ class CompactionProvider(ContextProvider):
         )
 
         projected = project_included_messages(all_messages)
-        projected_set = {id(m) for m in projected}
-        for sid in list(context.context_messages):
-            context.context_messages[sid] = [m for m in context.context_messages[sid] if id(m) in projected_set]
+
+        # Rebuild provider message lists from the projected list, preserving source attribution
+        # and including new synthetic messages created by compaction strategies
+        rebuilt: dict[str, list[Message]] = {sid: [] for sid in context.context_messages}
+        fallback_sid = next(iter(rebuilt), self.source_id)
+        last_sid = fallback_sid
+        for message in projected:
+            # For new synthetic messages, use the last known source; for original messages, use their tracked source
+            sid = source_by_id.get(id(message), last_sid)
+            if sid not in rebuilt:
+                # If the source was somehow removed during compaction, fall back to the last known source
+                sid = last_sid
+            rebuilt[sid].append(message)
+            last_sid = sid
+
+        context.context_messages.clear()
+        context.context_messages.update(rebuilt)
 
     async def after_run(
         self,