dasein-core 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

dasein/api.py

@@ -2714,8 +2714,9 @@ Follow these rules when planning your actions."""
                     trace = self._extract_trace_from_langgraph_result(result, extracted_query)
             
             if not trace:
-                print(f"[DASEIN] No trace available for synthesis")
-                return None
+                # Do not bail out – continue with empty trace so KPIs can still be recorded by the service
+                print(f"[DASEIN] No trace available for synthesis - continuing with empty trace for KPIs")
+                trace = []
             
             print(f"[DASEIN] Sending trace with {len(trace)} steps to post-run service")
             
@@ -2761,11 +2762,68 @@ Follow these rules when planning your actions."""
             cleaned_trace = clean_for_json(trace)
             
             # 3) Call post-run service for synthesis
+            # For retry > 1, wait for synthesis on all runs except the last one
+            wait_for_synthesis = False
+            if total_steps and step_number and step_number < total_steps:
+                wait_for_synthesis = True
+                print(f"[DASEIN] Will WAIT for rule synthesis (step {step_number}/{total_steps})")
+            
             if self._post_run == "kpi_only":
                 print(f"[DASEIN] Calling post-run service (KPI-only mode, no rule synthesis)")
             else:
-                print(f"[DASEIN] Calling post-run service for rule synthesis")
+                mode_str = "BLOCKING" if wait_for_synthesis else "ASYNC"
+                print(f"[DASEIN] Calling post-run service for rule synthesis ({mode_str} mode)")
             
+            # Compute agent fingerprint for post-run (mirror pre-run minimal fingerprint)
+            def _minimal_agent_fingerprint(agent) -> str:
+                try:
+                    agent_cls = getattr(agent, '__class__', None)
+                    agent_name = getattr(agent_cls, '__name__', '') if agent_cls else ''
+                    module = getattr(agent, '__module__', '') or ''
+                    framework = module.split('.')[0] if module else ''
+                    model_id = ''
+                    llm = getattr(agent, 'llm', None)
+                    if llm is not None:
+                        model_id = (
+                            getattr(llm, 'model', None)
+                            or getattr(llm, 'model_name', None)
+                            or getattr(llm, 'model_id', None)
+                            or getattr(llm, 'model_tag', None)
+                            or ''
+                        )
+                    tool_names = []
+                    tools_attr = getattr(agent, 'tools', None)
+                    if tools_attr:
+                        try:
+                            for t in tools_attr:
+                                name = getattr(t, 'name', None) or getattr(t, '__name__', None) or getattr(t.__class__, '__name__', '')
+                                if name:
+                                    tool_names.append(str(name))
+                        except Exception:
+                            pass
+                    elif getattr(agent, 'toolkit', None):
+                        tk = getattr(agent, 'toolkit')
+                        tk_tools = getattr(tk, 'tools', None) or getattr(tk, 'get_tools', None)
+                        try:
+                            iterable = tk_tools() if callable(tk_tools) else tk_tools
+                            for t in (iterable or []):
+                                name = getattr(t, 'name', None) or getattr(t, '__name__', None) or getattr(t.__class__, '__name__', '')
+                                if name:
+                                    tool_names.append(str(name))
+                        except Exception:
+                            pass
+                    norm = lambda s: str(s).strip().lower().replace(' ', '_') if s is not None else ''
+                    agent_name = norm(agent_name)
+                    framework = norm(framework)
+                    model_id = norm(model_id)
+                    tool_names = [norm(n) for n in tool_names if n]
+                    tools_joined = ','.join(sorted(set(tool_names)))
+                    return f"[[FINGERPRINT]] agent={agent_name} | framework={framework} | model={model_id} | tools={tools_joined}"
+                except Exception:
+                    return getattr(agent, 'agent_id', None) or f"agent_{id(agent)}"
+
+            agent_fingerprint = _minimal_agent_fingerprint(self._agent)
+
             response = self._service_adapter.synthesize_rules(
                 run_id=None,  # Will use stored run_id from pre-run phase
                 trace=cleaned_trace,
@@ -2776,9 +2834,10 @@ Follow these rules when planning your actions."""
                 max_rules=self._top_k,  # Configurable via top_k parameter
                 performance_tracking_id=self._performance_tracking_id,  # For rule isolation
                 skip_synthesis=skip_synthesis,  # Skip expensive synthesis when not needed
-                agent_fingerprint=getattr(self._agent, 'agent_id', None) or f"agent_{id(self._agent)}",
+                agent_fingerprint=agent_fingerprint,  # Reuse fingerprint from pre-run (line 2613)
                 step_id=self._current_step_id,  # Pass step_id for parallel execution tracking
-                post_run_mode=self._post_run  # Pass post_run mode ("full" or "kpi_only")
+                post_run_mode=self._post_run,  # Pass post_run mode ("full" or "kpi_only")
+                wait_for_synthesis=wait_for_synthesis  # Wait for synthesis on retry runs (except last)
             )
 
             # response is a dict from ServiceAdapter; handle accordingly

dasein/capture.py

@@ -405,10 +405,26 @@ class DaseinCallbackHandler(BaseCallbackHandler):
         
         # 🚨 OPTIMIZED: For LangGraph, check if kwargs contains 'invocation_params' with messages
         # Extract the most recent message instead of full history
+        # Use from_end=True to capture the END of system prompts (where user's actual query is)
         if 'invocation_params' in kwargs and 'messages' in kwargs['invocation_params']:
             args_excerpt = self._extract_recent_message({'messages': kwargs['invocation_params']['messages']})
         else:
-            args_excerpt = self._excerpt(" | ".join(modified_prompts))
+            args_excerpt = self._excerpt(" | ".join(modified_prompts), from_end=True)
+        
+        # GNN-related fields
+        step_index = len(self._trace)
+        
+        # Track which rules triggered at this step (llm_start rules)
+        rule_triggered_here = []
+        if hasattr(self, '_selected_rules') and self._selected_rules:
+            for rule_meta in self._selected_rules:
+                if isinstance(rule_meta, tuple) and len(rule_meta) == 2:
+                    rule_obj, _metadata = rule_meta
+                else:
+                    rule_obj = rule_meta
+                target_step_type = getattr(rule_obj, 'target_step_type', '')
+                if target_step_type in ['llm_start', 'chain_start']:
+                    rule_triggered_here.append(getattr(rule_obj, 'id', 'unknown'))
         
         step = {
             "step_type": "llm_start",
@@ -419,6 +435,9 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             "run_id": None,
             "parent_run_id": None,
             "node": self._current_chain_node,  # LangGraph node name (if available)
+            # GNN step-level fields
+            "step_index": step_index,
+            "rule_triggered_here": rule_triggered_here,
         }
         self._trace.append(step)
         # self._vprint(f"[DASEIN][CALLBACK] Captured llm_start: {len(_TRACE)} total steps")  # Commented out - too noisy
@@ -583,6 +602,15 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             import traceback
             traceback.print_exc()
         
+        # GNN-related fields: compute tokens_delta
+        step_index = len(self._trace)
+        tokens_delta = 0
+        # Find previous step with tokens_output to compute delta
+        for prev_step in reversed(self._trace):
+            if 'tokens_output' in prev_step and prev_step['tokens_output'] > 0:
+                tokens_delta = output_tokens - prev_step['tokens_output']
+                break
+        
         step = {
             "step_type": "llm_end",
             "tool_name": "",
@@ -594,6 +622,9 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             "tokens_input": input_tokens,
             "tokens_output": output_tokens,
             "node": self._current_chain_node,  # LangGraph node name (if available)
+            # GNN step-level fields
+            "step_index": step_index,
+            "tokens_delta": tokens_delta,
         }
         self._trace.append(step)
     
@@ -673,6 +704,21 @@ class DaseinCallbackHandler(BaseCallbackHandler):
         
         args_excerpt = self._excerpt(modified_input)
         
+        # GNN-related fields: capture step-level metrics
+        step_index = len(self._trace)
+        tool_input_chars = len(str(input_str))
+        
+        # Track which rules triggered at this step
+        rule_triggered_here = []
+        if hasattr(self, '_selected_rules') and self._selected_rules:
+            for rule_meta in self._selected_rules:
+                if isinstance(rule_meta, tuple) and len(rule_meta) == 2:
+                    rule_obj, _metadata = rule_meta
+                else:
+                    rule_obj = rule_meta
+                if getattr(rule_obj, 'target_step_type', '') == "tool_start":
+                    rule_triggered_here.append(getattr(rule_obj, 'id', 'unknown'))
+        
         step = {
             "step_type": "tool_start",
             "tool_name": tool_name,
@@ -682,6 +728,10 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             "run_id": run_id,
             "parent_run_id": parent_run_id,
             "node": self._current_chain_node,  # LangGraph node name (if available)
+            # GNN step-level fields
+            "step_index": step_index,
+            "tool_input_chars": tool_input_chars,
+            "rule_triggered_here": rule_triggered_here,
         }
         self._trace.append(step)
     
@@ -707,6 +757,24 @@ class DaseinCallbackHandler(BaseCallbackHandler):
         # self._vprint(f"[DASEIN][CALLBACK] Output length: {len(output_str)} chars")  # Commented out - too noisy
         # self._vprint(f"[DASEIN][CALLBACK] Outcome length: {len(outcome)} chars")  # Commented out - too noisy
         
+        # GNN-related fields: capture tool output metrics
+        step_index = len(self._trace)
+        tool_output_chars = len(output_str)
+        
+        # Estimate tool_output_items (heuristic: count lines, or rows if SQL-like)
+        tool_output_items = 0
+        try:
+            # Try to count lines as a proxy for items
+            if output_str:
+                tool_output_items = output_str.count('\n') + 1
+        except:
+            tool_output_items = 0
+        
+        # Extract available selectors from DOM-like output (web browse agents)
+        available_selectors = None
+        if tool_name in ['extract_text', 'get_elements', 'extract_hyperlinks', 'extract_content']:
+            available_selectors = self._extract_semantic_selectors(output_str)
+        
         step = {
             "step_type": "tool_end",
             "tool_name": tool_name,
@@ -716,7 +784,15 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             "run_id": run_id,
             "parent_run_id": parent_run_id,
             "node": self._current_chain_node,  # LangGraph node name (if available)
+            # GNN step-level fields
+            "step_index": step_index,
+            "tool_output_chars": tool_output_chars,
+            "tool_output_items": tool_output_items,
         }
+        
+        # Add available_selectors only if found (keep trace light)
+        if available_selectors:
+            step["available_selectors"] = available_selectors
         self._trace.append(step)
         
         # Clean up the stored tool name
@@ -880,12 +956,83 @@ class DaseinCallbackHandler(BaseCallbackHandler):
             # On any error, fall back to original behavior
             return self._excerpt(str(inputs))
     
-    def _excerpt(self, obj: Any, max_len: int = 250) -> str:
-        """Truncate text to max_length with ellipsis."""
+    def _excerpt(self, obj: Any, max_len: int = 250, from_end: bool = False) -> str:
+        """
+        Truncate text to max_length with ellipsis.
+        
+        Args:
+            obj: Object to convert to string and truncate
+            max_len: Maximum length of excerpt
+            from_end: If True, take LAST max_len chars (better for system prompts).
+                     If False, take FIRST max_len chars (better for tool args).
+        """
         text = str(obj)
         if len(text) <= max_len:
             return text
-        return text[:max_len-3] + "..."
+        
+        if from_end:
+            # Take last X chars - better for system prompts where the end contains user's actual query
+            return "..." + text[-(max_len-3):]
+        else:
+            # Take first X chars - better for tool inputs
+            return text[:max_len-3] + "..."
+    
+    def _extract_semantic_selectors(self, html_text: str) -> List[Dict[str, int]]:
+        """
+        Extract semantic HTML tags from output for grounding web browse rules.
+        Only extracts semantic tags (nav, header, h1, etc.) to keep trace lightweight.
+        
+        Args:
+            html_text: Output text that may contain HTML
+            
+        Returns:
+            List of {"tag": str, "count": int} sorted by count descending, or None if no HTML
+        """
+        import re
+        
+        # Quick check: does this look like HTML?
+        if '<' not in html_text or '>' not in html_text:
+            return None
+        
+        # Semantic tags we care about (prioritized for web browse agents)
+        semantic_tags = [
+            # Navigation/Structure (highest priority)
+            'nav', 'header', 'footer', 'main', 'article', 'section', 'aside',
+            
+            # Headers (critical for "find headers" queries!)
+            'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+            
+            # Interactive
+            'a', 'button', 'form', 'input', 'textarea', 'select', 'label',
+            
+            # Lists (often used for navigation)
+            'ul', 'ol', 'li',
+            
+            # Tables (data extraction)
+            'table', 'thead', 'tbody', 'tr', 'th', 'td',
+            
+            # Media
+            'img', 'video', 'audio'
+        ]
+        
+        # Count occurrences of each semantic tag
+        found_tags = {}
+        for tag in semantic_tags:
+            # Pattern: <tag ...> or <tag> (opening tags only)
+            pattern = f'<{tag}[\\s>]'
+            matches = re.findall(pattern, html_text, re.IGNORECASE)
+            if matches:
+                found_tags[tag] = len(matches)
+        
+        # Return None if no semantic tags found
+        if not found_tags:
+            return None
+        
+        # Convert to list format, sorted by count descending
+        # Limit to top 15 to keep trace light
+        result = [{"tag": tag, "count": count} 
+                  for tag, count in sorted(found_tags.items(), key=lambda x: -x[1])]
+        return result[:15]  # Top 15 most common tags
     
     def set_selected_rules(self, rules: List[Dict[str, Any]]):
         """Set the rules selected for this run.

{dasein_core-0.2.1.dist-info → dasein_core-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.1
+Version: 0.2.3
 Summary: Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line.
 Author-email: Dasein Team <support@dasein.ai>
 License: MIT

{dasein_core-0.2.1.dist-info → dasein_core-0.2.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 dasein/__init__.py,sha256=RY0lhaaWB6yJ_5YMRmaHDvQ0eFbc0BGbYNe5OVyxzYE,2316
 dasein/advice_format.py,sha256=5-h4J24L_B2Y9dlmyDuIYtmPCWOGAYoinBEXqpcNg2s,5386
-dasein/api.py,sha256=yVR5CoHIIHV9DedRFEpw8pY0EkLovSqJH1-tvR7uZ_Q,172105
-dasein/capture.py,sha256=pTneyQPhJCBUPyIpOCsRtU-W7Wprw5IXdMkeN_bbh0E,74330
+dasein/api.py,sha256=yYymqTKwtUuQ1dnHFHt9L7OuEXQddVjyxBMa8Py4MmE,175714
+dasein/capture.py,sha256=IhvG-seZW5dyX-6COR4w9Xhe1oJ-QltCvg158qjhEb4,80743
 dasein/config.py,sha256=lXO8JG4RXbodn3gT5yEnuB0VRwWdrRVwhX3Rm06IZmU,1957
 dasein/events.py,sha256=mG-lnOvQoZUhXbrPSjrG4RME6ywUcbSZ04PscoJ15GI,12896
 dasein/extractors.py,sha256=fUFBVH9u2x4cJaM-8Zw4qiIpBF2LvjcdYkMvoXQUpL8,3986
@@ -14,8 +14,8 @@ dasein/services/post_run_client.py,sha256=bzWKiu-FGo36r6J-QBv6zjLpjI7mMjKmjhvfid
 dasein/services/pre_run_client.py,sha256=tXmz_PQaSfq0xwypiWUAqNkXOmREZ6EwXLC4OM89J-A,4317
 dasein/services/service_adapter.py,sha256=nVvPPioYKoxYmR33w1ssYx422UPBeTsq8yIKZum8YHg,7128
 dasein/services/service_config.py,sha256=8_4tpV4mZvfaOc5_yyHbOyL4rYsPHzkLTEY1rtYgLs8,1629
-dasein_core-0.2.1.dist-info/licenses/LICENSE,sha256=7FHjIFEKl_3hSc3tGUVEWmufC_3oi8rh_2zVuL7jMKs,1091
-dasein_core-0.2.1.dist-info/METADATA,sha256=MdnWuESn6u1_HF6-xTQVsY7cNoLVT54_lQGW4aNV3-U,10192
-dasein_core-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dasein_core-0.2.1.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
-dasein_core-0.2.1.dist-info/RECORD,,
+dasein_core-0.2.3.dist-info/licenses/LICENSE,sha256=7FHjIFEKl_3hSc3tGUVEWmufC_3oi8rh_2zVuL7jMKs,1091
+dasein_core-0.2.3.dist-info/METADATA,sha256=WZXHvAbvT5mir7Mii-21FHeKc-ss_dSh48fXbAPKW7w,10192
+dasein_core-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dasein_core-0.2.3.dist-info/top_level.txt,sha256=6yYY9kltjvvPsg9K6KyMKRtzEr5qM7sHXN7VzmrDtp0,7
+dasein_core-0.2.3.dist-info/RECORD,,