execweave 0.8.24__tar.gz → 0.8.25__tar.gz

{execweave-0.8.24 → execweave-0.8.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.24
+Version: 0.8.25
 Summary: Turn AI-agent runtime behavior into a local interactive execution graph.
 Project-URL: Homepage, https://github.com/Irish-kw/ExecWeave
 Project-URL: Repository, https://github.com/Irish-kw/ExecWeave

{execweave-0.8.24 → execweave-0.8.25}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.24 release metadata
-version = "0.8.24"
+# ExecWeave v0.8.25 release metadata
+version = "0.8.25"
 description = "Turn AI-agent runtime behavior into a local interactive execution graph."
 readme = "README.md"
 requires-python = ">=3.10"

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.24"
+__version__ = "0.8.25"

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/_conversation_records_core.py

@@ -47,6 +47,9 @@ _CONVERSATION_TOKENS = (
     "request_prompt",
     "request_input",
     "model_context_messages",
+    "model_request",
+    "model_response",
+    "model_failure",
 )
 
 

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/conversation_preview_common.py

@@ -5,6 +5,9 @@ from typing import Any
 
 from .agent_topology import (
     THREAD_ID_EXECWEAVE_DERIVED,
+    THREAD_ID_PROVIDER_NATIVE,
+    PATH_PROVIDER_DECLARED,
+    TOPOLOGY_OBSERVED,
     resolve_agent_topology,
 )
 from .conversation_preview_generic import (  # noqa: F401
@@ -93,6 +96,28 @@ def _agent_identity(provider: str, source: dict[str, Any] | None) -> dict[str, A
     source_id_text = source_id if isinstance(source_id, str) else ""
     provider_label = _provider_label(provider)
     provider_key = provider.lower() or "provider"
+    if attrs.get("conversation_scope") == "framework_agent":
+        native_id = str(attrs.get("conversation_agent_id") or source_id_text or "agent")
+        agent_path = attrs.get("conversation_agent_path")
+        if not isinstance(agent_path, str) or not agent_path.strip():
+            agent_path = f"/{provider_key}/{native_id}"
+        label = source_name or attrs.get("conversation_agent_name") or native_id
+        return {
+            "thread_id": f"{provider_key}:agent:{native_id}",
+            "thread_id_source": THREAD_ID_PROVIDER_NATIVE,
+            "parent_thread_id": None,
+            "agent_label": str(label),
+            "provider_label": provider_label,
+            "agent_nickname": None,
+            "agent_path": agent_path,
+            "agent_path_source": PATH_PROVIDER_DECLARED,
+            "topology_state": TOPOLOGY_OBSERVED,
+            "topology_evidence": "framework_agent_boundary",
+            "parent_agent_path": None,
+            "parent_relation_source": None,
+            "provider_native_id": native_id,
+            "is_root": False,
+        }
     topology = resolve_agent_topology(source)
     agent_path = topology.agent_path
     is_root = topology.is_root

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/conversation_preview_generic.py

@@ -64,6 +64,12 @@ def _routed_agent_message(
         return []
     sender = value.get("sender")
     recipient = value.get("recipient")
+    if recipient is None and isinstance(value.get("recipients"), list):
+        recipient = ", ".join(
+            str(item).strip()
+            for item in value["recipients"]
+            if str(item).strip()
+        ) or None
     kind = value.get("kind")
     phase = value.get("phase")
     task_name = value.get("task_name")
@@ -101,6 +107,15 @@ def _generic_content_messages(
         routed = _routed_agent_message(value, timestamp=timestamp, ordinal=ordinal, agent_path=agent_path)
         if routed:
             return routed
+    if "model_request" in kind or "model_response" in kind or "model_failure" in kind:
+        structured = _structured_messages(value, timestamp=timestamp, ordinal=ordinal, agent_path=agent_path)
+        if structured:
+            return structured
+        text = _text_parts(value)
+        if text:
+            if "model_request" in kind:
+                return [_message(timestamp=timestamp, ordinal=ordinal, kind="model_request", sender="context", recipient=agent_path, text=text, phase="request")]
+            return [_message(timestamp=timestamp, ordinal=ordinal, kind="assistant_message", sender=agent_path, recipient=None, text=text, phase="response")]
     text = _text_parts(value)
     if not text:
         return []

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/conversation_preview_lines.py

@@ -24,6 +24,13 @@ def _structured_messages(
     if isinstance(value, dict):
         if isinstance(value.get("message"), dict):
             candidates.append(value["message"])
+        if isinstance(value.get("messages"), list):
+            for item in value["messages"]:
+                if isinstance(item, dict):
+                    if isinstance(item.get("message"), dict):
+                        candidates.append(item["message"])
+                    elif any(key in item for key in ("role", "content", "text")):
+                        candidates.append(item)
         elif any(key in value for key in ("role", "content", "text")):
             candidates.append(value)
     elif isinstance(value, list):
@@ -41,10 +48,20 @@ def _structured_messages(
         text = _text_parts(item.get("content")) or _text_parts(item.get("text"))
         if not text:
             continue
+        sender = item.get("source") or item.get("sender")
+        recipient = item.get("recipient") or item.get("target")
+        if recipient is None and isinstance(item.get("recipients"), list):
+            recipient = ", ".join(
+                str(value).strip()
+                for value in item["recipients"]
+                if str(value).strip()
+            ) or None
+        sender = sender.strip() if isinstance(sender, str) and sender.strip() else None
+        recipient = recipient.strip() if isinstance(recipient, str) and recipient.strip() else None
         if role in {"user", "human"}:
-            messages.append(_message(timestamp=timestamp, ordinal=ordinal, kind="user_message", sender="user", recipient=agent_path, text=text))
+            messages.append(_message(timestamp=timestamp, ordinal=ordinal, kind="user_message", sender=sender or "user", recipient=recipient or agent_path, text=text))
         elif role in {"assistant", "model", "agent"}:
-            messages.append(_message(timestamp=timestamp, ordinal=ordinal, kind="assistant_message", sender=agent_path, recipient=None, text=text, phase="response"))
+            messages.append(_message(timestamp=timestamp, ordinal=ordinal, kind="assistant_message", sender=sender or agent_path, recipient=recipient, text=text, phase="response"))
     return messages
 
 

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/framework_adapters/autogen.py

@@ -185,6 +185,11 @@ class AutoGenAdapter(FrameworkAdapter):
             source = self._agents.get(str(source_name)) or self.observe_agent(
                 str(source_name), name=str(source_name)
             )
+        target_name = getattr(event, "target", None) or getattr(event, "recipient", None)
+        if target is None and target_name is not None:
+            target = self._agents.get(str(target_name)) or self.observe_agent(
+                str(target_name), name=str(target_name)
+            )
         content = getattr(event, "content", None)
         if event_name == "ThoughtEvent":
             return self.observe_message(

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/framework_adapters/base.py

@@ -92,6 +92,12 @@ def _string(value: Any) -> str | None:
     return text or None
 
 
+def _entity_label(entity: EntityRef | None) -> str | None:
+    if entity is None:
+        return None
+    return entity.name or entity.id
+
+
 @dataclass(frozen=True)
 class EntityRef:
     type: str
@@ -307,6 +313,7 @@ class MessageRecord:
     content_kind: str = "message"
     direction: Literal["sent", "received"] = "sent"
     attributes: Mapping[str, Any] = field(default_factory=dict)
+    content_payload: Any | None = None
 
 
 @dataclass(frozen=True)
@@ -390,28 +397,73 @@ class AdapterContext:
         return record.task
 
     def record_message(self, record: MessageRecord) -> EntityRef:
-        reference = self.content.put_text(record.content, content_kind=record.content_kind) if record.content is not None else None
-        attrs = {"message_id": record.message.id, "role": record.role, "task_id": record.task.id if record.task else None, "parent_message_id": record.parent_message.id if record.parent_message else None, **self.content.reference_attributes(reference), **dict(record.attributes)}
+        content_kind = f"{self.framework}.agent_message"
+        message_payload = record.content_payload if record.content_payload is not None else {
+            "message_id": record.message.id,
+            "text": record.content,
+            "sender": _entity_label(record.source),
+            "recipient": _entity_label(record.target),
+            "role": record.role,
+            "kind": "agent_message",
+            "phase": "received" if record.direction == "received" else "sent",
+            "content_state": "plaintext",
+        }
+        reference = self.content.put_json(message_payload, content_kind=content_kind) if record.content is not None else None
+        attrs = {"message_id": record.message.id, "role": record.role, "task_id": record.task.id if record.task else None, "parent_message_id": record.parent_message.id if record.parent_message else None, "sender_agent_id": record.source.id if record.source and record.source.type == "agent" else None, "recipient_agent_id": record.target.id if record.target and record.target.type == "agent" else None, **self.content.reference_attributes(reference), **dict(record.attributes)}
         event_type = "MESSAGE_SENT" if record.direction == "sent" else "MESSAGE_RECEIVED"
         self.emit(event_type, event_type, source=record.source, target=record.target or record.message, attributes=attrs)
         if reference is not None:
             content = EntityRef("observed_content", f"observed-content:message:sha256:{reference.sha256}", reference.content_kind, reference.to_dict())
-            self.emit("MESSAGE_CONTENT_RECORDED", "HAS_MESSAGE_CONTENT", source=record.message, target=content, attributes={"message_id": record.message.id, **self.content.reference_attributes(reference)})
+            participants: list[tuple[EntityRef, str]] = []
+            for side, participant in (("sender", record.source), ("recipient", record.target)):
+                if participant is None or participant.type != "agent":
+                    continue
+                if any(existing.id == participant.id for existing, _ in participants):
+                    participants = [(existing, "sender_and_recipient" if existing.id == participant.id else existing_side) for existing, existing_side in participants]
+                    continue
+                participants.append((participant, side))
+            if not participants:
+                participants = [(record.message, "message")]
+            for participant, side in participants:
+                self.emit(
+                    "MESSAGE_CONTENT_RECORDED",
+                    "HAS_MESSAGE_CONTENT",
+                    source=participant,
+                    target=content,
+                    attributes={
+                        "message_id": record.message.id,
+                        "conversation_scope": "agent" if participant.type == "agent" else "message",
+                        "conversation_side": side,
+                        "conversation_agent_id": participant.id if participant.type == "agent" else None,
+                        **self.content.reference_attributes(reference),
+                    },
+                )
         return record.message
 
     def record_model_call(self, record: ModelCallRecord) -> EntityRef:
         if record.status == "request":
-            event_type, relation, value, kind = "MODEL_REQUEST", "REQUESTS_MODEL_CALL", record.request, record.content_kind or "model_request"
+            event_type, relation, value, kind = "MODEL_REQUEST", "REQUESTS_MODEL_CALL", record.request, f"{self.framework}.model_request"
         elif record.status == "response":
-            event_type, relation, value, kind = "MODEL_RESPONSE", "MODEL_CALL_RESPONDS", record.response, record.content_kind or "model_response"
+            event_type, relation, value, kind = "MODEL_RESPONSE", "MODEL_CALL_RESPONDS", record.response, f"{self.framework}.model_response"
         else:
-            event_type, relation, value, kind = "MODEL_FAILURE", "MODEL_CALL_FAILED", record.response or record.request, record.content_kind or "model_failure"
+            event_type, relation, value, kind = "MODEL_FAILURE", "MODEL_CALL_FAILED", record.response or record.request, f"{self.framework}.model_failure"
         reference = self.content.put_text(value, content_kind=kind) if isinstance(value, str) else self.content.put_json(value, content_kind=kind) if value is not None else None
         attrs = {"model_call_id": record.model_call.id, "task_id": record.task.id if record.task else None, "requesting_agent_id": record.requesting_agent.id if record.requesting_agent else None, **self.content.reference_attributes(reference), **dict(record.attributes)}
         self.emit(event_type, relation, source=record.requesting_agent, target=record.model, attributes=attrs)
         if reference is not None:
             content = EntityRef("observed_content", f"observed-content:model:sha256:{reference.sha256}", reference.content_kind, reference.to_dict())
-            self.emit("MODEL_CONTENT_RECORDED", "HAS_MODEL_CONTENT", source=record.model_call, target=content, attributes={"model_call_id": record.model_call.id, **self.content.reference_attributes(reference)})
+            self.emit(
+                "MODEL_CONTENT_RECORDED",
+                "HAS_MODEL_CONTENT",
+                source=record.requesting_agent or record.model_call,
+                target=content,
+                attributes={
+                    "model_call_id": record.model_call.id,
+                    "conversation_scope": "agent" if record.requesting_agent is not None else "model_call",
+                    "conversation_agent_id": record.requesting_agent.id if record.requesting_agent else None,
+                    **self.content.reference_attributes(reference),
+                },
+            )
         return record.model_call
 
     def record_tool_call(self, record: ToolCallRecord) -> EntityRef:
@@ -452,7 +504,14 @@ class FrameworkAdapter:
         return self.context.emit(event_type, relation, **kwargs)
 
     def agent(self, native_id: str | int, *, name: str | None = None, **attributes: Any) -> EntityRef:
-        return self.entity("agent", native_id, name=name, attributes=attributes)
+        native = _ID_SAFE.sub("_", str(native_id).strip()) or "agent"
+        values = {
+            "conversation_scope": "framework_agent",
+            "conversation_agent_id": str(native_id),
+            "conversation_agent_path": f"/{self.framework_name}/{native}",
+            **attributes,
+        }
+        return self.entity("agent", native_id, name=name, attributes=values)
 
     def task(self, native_id: str | int, *, name: str | None = None, **attributes: Any) -> EntityRef:
         return self.entity("task", native_id, name=name, attributes=attributes)

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/framework_adapters/camel.py

@@ -14,13 +14,14 @@ class CAMELAdapter(FrameworkAdapter):
         events=("AGENT_CREATED", "AGENT_STARTED", "AGENT_STOPPED", "TASK_CREATED", "TASK_ASSIGNED", "TASK_STARTED", "TASK_UPDATED", "TASK_COMPLETED", "TASK_FAILED", "MESSAGE_SENT", "MESSAGE_RECEIVED", "MODEL_REQUEST", "MODEL_RESPONSE", "MODEL_FAILURE"),
         content_modes=("metadata_only", "content_ref_only", "prompt_only", "prompt_and_response"),
         authoritative_surfaces=("camel.societies.workforce.WorkforceCallback", "camel.models.BaseModelBackend.run", "camel.models.BaseModelBackend.arun"),
-        known_limitations=("WorkforceCallback does not expose every message boundary; callers must use an authoritative model/message hook.", "A created worker is not treated as assigned until CAMEL reports a task assignment."),
+        known_limitations=("WorkforceCallback LogEvent does not expose the emitting worker or recipient; those log messages remain explicitly unrouted unless a stream-chunk or model/message hook supplies the boundary.", "A created worker is not treated as assigned until CAMEL reports a task assignment."),
     )
 
     def __init__(self, context: AdapterContext) -> None:
         super().__init__(context)
         self._agents: dict[str, EntityRef] = {}
         self._tasks: dict[str, EntityRef] = {}
+        self._message_counter = 0
 
     @classmethod
     def compatibility(cls) -> FrameworkCompatibility:
@@ -91,19 +92,28 @@ class CAMELAdapter(FrameworkAdapter):
         payload = _payload(args, kwargs)
         if name in {"log_message", "log_stream_chunk"}:
             content = _string(_value(payload, "message", "text"))
-            message_id = _native(payload, "message_id", "id", "task_id", "worker_id")
+            native_message_id = _value(payload, "message_id", "id", "task_id", "worker_id")
+            self._message_counter += 1
+            message_id = (
+                native_message_id
+                if isinstance(native_message_id, (str, int)) and str(native_message_id)
+                else f"{self.framework_name}-message-{self._message_counter}"
+            )
             worker_id = _value(payload, "worker_id", "agent_id")
             source = self._agents.get(str(worker_id)) if worker_id is not None else None
+            target_id = _value(payload, "target_worker_id", "recipient_worker_id", "target_agent_id", "recipient_agent_id", "receiver_id")
+            target = self._agents.get(str(target_id)) if target_id is not None else None
             return self.message(
                 message_id,
                 source,
-                None,
+                target,
                 content=content,
                 role="stream" if name == "log_stream_chunk" else "log",
                 attributes={
                     "callback_name": name,
                     "event_type": _value(payload, "event_type"),
                     "metadata": _value(payload, "metadata"),
+                    "message_id_source": "provider" if native_message_id is not None else "execweave_derived",
                 },
             )
         if name == "log_task_decomposed":

{execweave-0.8.24 → execweave-0.8.25}/src/execweave/framework_adapters/metagpt.py

@@ -121,6 +121,7 @@ class MetaGPTAdapter(FrameworkAdapter):
         role: str | None = None,
         task: EntityRef | None = None,
         received: bool = False,
+        content_payload: Any | None = None,
         **attributes: Any,
     ) -> EntityRef:
         message = self.entity("message", message_id, name="MetaGPT message", attributes={"provider": "metagpt"})
@@ -132,6 +133,7 @@ class MetaGPTAdapter(FrameworkAdapter):
                 role=role,
                 task=task,
                 content=content,
+                content_payload=content_payload,
                 direction="received" if received else "sent",
                 attributes=attributes,
             )
@@ -145,19 +147,62 @@ class MetaGPTAdapter(FrameworkAdapter):
         source_name = getattr(message_object, "sent_from", None)
         target_name = getattr(message_object, "send_to", None)
         source = self._roles.get(str(source_name)) if source_name else None
-        target = self._roles.get(str(target_name)) if isinstance(target_name, str) else None
-        return self.observe_message(
-            message_id,
-            source=source,
-            target=target,
-            content=_text(getattr(message_object, "content", None)),
-            role=_text(getattr(message_object, "role", None)),
-            task=task,
-            cause_by=_text(getattr(message_object, "cause_by", None)),
-            metadata=getattr(message_object, "metadata", None),
-            message_type=type(message_object).__name__,
+        content = _text(getattr(message_object, "content", None))
+        role = _text(getattr(message_object, "role", None))
+        common_attributes = {
+            "cause_by": _text(getattr(message_object, "cause_by", None)),
+            "metadata": getattr(message_object, "metadata", None),
+            "message_type": type(message_object).__name__,
             **attributes,
-        )
+        }
+        target_names = None
+        if isinstance(target_name, (list, tuple, set, frozenset)):
+            target_names = list(target_name)
+            if isinstance(target_name, (set, frozenset)):
+                target_names.sort(key=str)
+            targets = [self._roles.get(str(name)) for name in target_names if name]
+            targets = [target for target in targets if target is not None]
+        else:
+            target = self._roles.get(str(target_name)) if isinstance(target_name, str) else None
+            targets = [target] if target is not None else []
+        shared_content_payload = None
+        if target_names is not None and targets:
+            recipient_labels = [target.name or target.id for target in targets]
+            shared_content_payload = {
+                "message_id": message_id,
+                "text": content,
+                "sender": source.name or source.id if source is not None else None,
+                "recipient": recipient_labels[0] if len(recipient_labels) == 1 else None,
+                "recipients": recipient_labels,
+                "role": role,
+                "kind": "agent_message",
+                "phase": "sent",
+                "content_state": "plaintext",
+            }
+        if not targets:
+            return self.observe_message(
+                message_id,
+                source=source,
+                target=None,
+                content=content,
+                role=role,
+                task=task,
+                content_payload=shared_content_payload,
+                **common_attributes,
+            )
+        message = None
+        for target in targets:
+            message = self.observe_message(
+                message_id,
+                source=source,
+                target=target,
+                content=content,
+                role=role,
+                task=task,
+                content_payload=shared_content_payload,
+                **common_attributes,
+            )
+        return message
 
     def observe_action(
         self,