execweave 0.8.25__tar.gz → 0.8.28__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.25
+Version: 0.8.28
 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.25 → execweave-0.8.28}/pyproject.toml

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

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

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

{execweave-0.8.25 → execweave-0.8.28}/src/execweave/collector.py

@@ -75,7 +75,15 @@ def _safe_process_snapshot(proc: psutil.Process) -> ProcessSnapshot | None:
                 exe=exe,
                 create_time=proc.create_time(),
             )
-    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+    except (
+        psutil.NoSuchProcess,
+        psutil.AccessDenied,
+        psutil.ZombieProcess,
+        # macOS can surface protected-process cmdline denial as a SystemError
+        # from psutil's C extension instead of AccessDenied. Treat that process
+        # as unobservable, just like the other permission-race cases.
+        SystemError,
+    ):
         return None
 
 

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

@@ -33,8 +33,9 @@ CANONICAL_EVENT_TYPES = frozenset(
     {
         "AGENT_CREATED", "AGENT_STARTED", "AGENT_STOPPED",
         "TASK_CREATED", "TASK_ASSIGNED", "TASK_STARTED", "TASK_UPDATED",
+        "TASK_CONTENT_RECORDED",
         "TASK_COMPLETED", "TASK_FAILED",
-        "MESSAGE_SENT", "MESSAGE_RECEIVED",
+        "MESSAGE_SENT", "MESSAGE_RECEIVED", "MESSAGE_UNROUTED",
         "MODEL_REQUEST", "MODEL_RESPONSE", "MODEL_FAILURE",
         "TOOL_CALL", "TOOL_RESULT", "TOOL_FAILURE",
         "MESSAGE_CONTENT_RECORDED", "MODEL_CONTENT_RECORDED", "TOOL_CONTENT_RECORDED",
@@ -298,6 +299,8 @@ class TaskRecord:
     task: EntityRef
     owner: EntityRef | None = None
     parent_task: EntityRef | None = None
+    content: str | None = None
+    content_kind: str = "task_prompt"
     attributes: Mapping[str, Any] = field(default_factory=dict)
 
 
@@ -391,9 +394,38 @@ class AdapterContext:
         return record.agent
 
     def record_task(self, record: TaskRecord, *, event_type: str = "TASK_CREATED") -> EntityRef:
-        self.emit(event_type, event_type, source=record.owner, target=record.task, attributes={"parent_task_id": record.parent_task.id if record.parent_task else None, **dict(record.attributes)})
+        content_reference = None
+        if record.content is not None:
+            content_kind = record.content_kind
+            if "." not in content_kind:
+                content_kind = f"{self.framework}.{content_kind}"
+            content_reference = self.content.put_text(record.content, content_kind=content_kind)
+        task_attributes = {
+            "parent_task_id": record.parent_task.id if record.parent_task else None,
+            **self.content.reference_attributes(content_reference),
+            **dict(record.attributes),
+        }
+        self.emit(event_type, event_type, source=record.owner, target=record.task, attributes=task_attributes)
         if record.parent_task is not None:
             self.emit("TASK_CREATED", "PARENT_TASK", source=record.parent_task, target=record.task, attributes={"parent_task_id": record.parent_task.id})
+        if content_reference is not None:
+            content = EntityRef(
+                "observed_content",
+                f"observed-content:task:sha256:{content_reference.sha256}",
+                content_reference.content_kind,
+                content_reference.to_dict(),
+            )
+            self.emit(
+                "TASK_CONTENT_RECORDED",
+                "HAS_TASK_CONTENT",
+                source=record.task,
+                target=content,
+                attributes={
+                    "task_id": record.task.id,
+                    "conversation_scope": "task",
+                    **self.content.reference_attributes(content_reference),
+                },
+            )
         return record.task
 
     def record_message(self, record: MessageRecord) -> EntityRef:

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

@@ -11,16 +11,17 @@ from .base import AdapterCapabilities, AdapterContext, AgentRecord, EntityRef, F
 class CAMELAdapter(FrameworkAdapter):
     framework_name = "camel"
     capabilities = AdapterCapabilities(
-        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"),
+        events=("AGENT_CREATED", "AGENT_STARTED", "AGENT_STOPPED", "TASK_CREATED", "TASK_ASSIGNED", "TASK_STARTED", "TASK_UPDATED", "TASK_COMPLETED", "TASK_FAILED", "TASK_CONTENT_RECORDED", "MESSAGE_SENT", "MESSAGE_RECEIVED", "MESSAGE_UNROUTED", "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 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."),
+        known_limitations=("WorkforceCallback LogEvent does not expose the emitting worker or recipient; those log messages are explicitly marked MESSAGE_UNROUTED and correlated to the observed process instead of being assigned to a guessed agent.", "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._active_tasks_by_agent: dict[str, EntityRef] = {}
         self._message_counter = 0
 
     @classmethod
@@ -44,18 +45,40 @@ class CAMELAdapter(FrameworkAdapter):
     def agent_stopped(self, agent: EntityRef, **attributes: Any) -> None:
         self.emit("AGENT_STOPPED", "AGENT_STOPPED", source=agent, attributes=attributes)
 
-    def task_event(self, event_type: str, native_id: str | int, *, name: str | None = None, owner: EntityRef | None = None, parent: EntityRef | None = None, **attributes: Any) -> EntityRef:
-        task = self.task(native_id, name=name, provider="camel", **attributes)
+    def task_event(self, event_type: str, native_id: str | int, *, name: str | None = None, owner: EntityRef | None = None, parent: EntityRef | None = None, content: str | None = None, content_kind: str = "task_prompt", **attributes: Any) -> EntityRef:
+        existing = self._tasks.get(str(native_id))
+        if existing is not None and name is None and content is None and not attributes:
+            task = existing
+        else:
+            entity_attributes = dict(attributes)
+            if content is not None:
+                entity_attributes.setdefault("task_prompt", content)
+            task = self.task(native_id, name=name, provider="camel", **entity_attributes)
         self._tasks[str(native_id)] = task
-        self.context.record_task(TaskRecord(task, owner=owner, parent_task=parent, attributes=attributes), event_type=event_type)
+        self.context.record_task(
+            TaskRecord(
+                task,
+                owner=owner,
+                parent_task=parent,
+                content=content,
+                content_kind=content_kind,
+                attributes=attributes,
+            ),
+            event_type=event_type,
+        )
         return task
 
     def task_created(self, native_id: str | int, **kwargs: Any) -> EntityRef:
         return self.task_event("TASK_CREATED", native_id, **kwargs)
 
     def task_assigned(self, task: EntityRef, agent: EntityRef, **attributes: Any) -> None:
+        self._active_tasks_by_agent[agent.id] = task
         self.emit("TASK_ASSIGNED", "ASSIGNED_TO", source=task, target=agent, attributes=attributes)
 
+    def active_task_for(self, agent: EntityRef | None) -> EntityRef | None:
+        """Return the latest provider-observed task assigned to an agent."""
+        return self._active_tasks_by_agent.get(agent.id) if agent is not None else None
+
     def task_started(self, task: EntityRef, agent: EntityRef | None = None, **attributes: Any) -> None:
         self.emit("TASK_STARTED", "TASK_STARTED", source=agent or task, target=task, attributes=attributes)
 
@@ -73,6 +96,32 @@ class CAMELAdapter(FrameworkAdapter):
         self.context.record_message(MessageRecord(message, source, target, role=role, task=task, content=content, direction="received" if received else "sent", attributes=attributes))
         return message
 
+    def message_unrouted(self, message: EntityRef, *, callback_name: str, missing_sender: bool, missing_recipient: bool, reason: str = "callback_payload_missing_agent_boundary") -> None:
+        """Keep callback messages visible without inventing an agent route.
+
+        CAMEL's WorkforceCallback log surface can emit a message without a
+        worker or recipient.  The process is the only authoritative boundary
+        available in that case, so record that boundary explicitly rather
+        than leaving the message looking like a dropped graph node.
+        """
+        process = self.context.process
+        if process is None:
+            return
+        self.emit(
+            "MESSAGE_UNROUTED",
+            "OBSERVED_AT_PROCESS",
+            source=message,
+            target=process.to_entity(),
+            attributes={
+                "callback_name": callback_name,
+                "routing_status": "unrouted",
+                "routing_reason": reason,
+                "missing_sender": missing_sender,
+                "missing_recipient": missing_recipient,
+                "routing_basis": "authoritative_process_boundary",
+            },
+        )
+
     def model_call(self, call_id: str | int, agent: EntityRef | None, model_id: str | int, *, model_name: str | None = None, request: Any | None = None, response: Any | None = None, status: str = "request", task: EntityRef | None = None, **attributes: Any) -> EntityRef:
         model = self.model(model_id, name=model_name, provider="camel", **attributes)
         call = self.entity("model_call", call_id, name="CAMEL model call", attributes={"provider": "camel"})
@@ -103,7 +152,7 @@ class CAMELAdapter(FrameworkAdapter):
             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 = self.message(
                 message_id,
                 source,
                 target,
@@ -116,6 +165,14 @@ class CAMELAdapter(FrameworkAdapter):
                     "message_id_source": "provider" if native_message_id is not None else "execweave_derived",
                 },
             )
+            if source is None or target is None:
+                self.message_unrouted(
+                    message,
+                    callback_name=name,
+                    missing_sender=source is None,
+                    missing_recipient=target is None,
+                )
+            return message
         if name == "log_task_decomposed":
             parent_key = _native(payload, "parent_task_id", "task_id", "id")
             parent = self._tasks.get(str(parent_key)) or self.task_created(parent_key)
@@ -136,7 +193,11 @@ class CAMELAdapter(FrameworkAdapter):
         if name == "log_worker_created":
             return self.agent_created(_native(payload, "worker_id", "id", "name"), name=_string(_value(payload, "name", "role")), role=_string(_value(payload, "role", "worker_type")))
         if name == "log_task_created":
-            return self.task_created(_native(payload, "task_id", "id", "name"), name=_string(_value(payload, "name", "description")))
+            task_key = _native(payload, "task_id", "id", "name")
+            existing = self._tasks.get(str(task_key))
+            if existing is not None:
+                return existing
+            return self.task_created(task_key, name=_string(_value(payload, "name", "description")))
         if name == "log_task_assigned":
             task_key = _native(payload, "task_id", "id", "name")
             task = self._tasks.get(str(task_key)) or self.task_created(task_key)

{execweave-0.8.25 → execweave-0.8.28}/src/execweave/strace_backend.py

@@ -49,6 +49,12 @@ def _iso_timestamp(value: float) -> str:
 
 
 def _decode_quoted(value: str) -> str:
+    # Synthetic Windows traces carry native drive paths with single
+    # backslashes (for example ``C:\\tmp``).  Treating those as Python string
+    # escapes turns ``\\t`` into a tab and corrupts the observed path.  Real
+    # Linux strace paths still use the normal C-style decoding below.
+    if re.match(r"^[A-Za-z]:[\\/]", value):
+        return value.replace(r'\"', '"').replace(r"\\", "\\")
     try:
         return str(ast.literal_eval(f'"{value}"'))
     except (SyntaxError, ValueError):

{execweave-0.8.25 → execweave-0.8.28}/src/execweave/viewer_agent_panel.py

@@ -372,6 +372,10 @@ function execweaveNodeCardsBase(node){
     add('Command',a.command);
     add('Working directory',a.cwd);
     add('Backend',a.backend);
+  }else if(kind==='task'){
+    add('Task',a.task_prompt||a.prompt||a.description||node?.name);
+    add('Prompt',a.task_prompt||a.prompt||a.description);
+    add('Provider',a.provider);
   }else if(kind==='network_endpoint'){
     const endpoints=Array.isArray(a.endpoints)?a.endpoints:[];
     if(endpoints.length){