dasein-core 0.2.2__tar.gz → 0.2.3__tar.gz

{dasein_core-0.2.2/src/dasein_core.egg-info → dasein_core-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.2
+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.2 → dasein_core-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dasein-core"
-version = "0.2.2"
+version = "0.2.3"
 description = "Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line."
 readme = "README.md"
 requires-python = ">=3.8"

{dasein_core-0.2.2 → dasein_core-0.2.3}/src/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")
             
@@ -2773,6 +2774,56 @@ Follow these rules when planning your actions."""
                 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,
@@ -2783,7 +2834,7 @@ 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")
                 wait_for_synthesis=wait_for_synthesis  # Wait for synthesis on retry runs (except last)

{dasein_core-0.2.2 → dasein_core-0.2.3}/src/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.2 → dasein_core-0.2.3/src/dasein_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.2
+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