npcpy 1.3.21__py3-none-any.whl → 1.3.23__py3-none-any.whl

npcpy/llm_funcs.py

@@ -681,43 +681,60 @@ def _react_fallback(
     # Cap iterations - after this, return to orchestrator for review/compression
     effective_max = min(max_iterations, 7)
 
+    original_command = command  # Preserve original request
+
     for iteration in range(effective_max):
-        # Build history of what's been tried
-        history_text = ""
         if jinx_executions:
-            history_text = "\n\nPrevious tool calls this session:\n" + "\n".join(
-                f"- {h['name']}({h['inputs']}) -> {h['output']}"
-                for h in jinx_executions[-5:]
-            )
+            # Tools have already been called — ask model to answer WITHOUT showing tools
+            last_result = str(jinx_executions[-1].get('output', ''))[:1000]
+            prompt = f"""The user asked: {original_command}
+
+You already ran a tool and got: {last_result}
 
-        prompt = f"""Request: {command}
+Answer the user now. Respond with this JSON:
+{{"action": "answer", "response": "your answer based on the tool result"}}"""
+
+            # Don't pass npc on answer-nudge iterations to avoid system prompt
+            # re-injecting tool descriptions that bias toward more tool calls
+            response = get_llm_response(
+                prompt,
+                model=model,
+                provider=provider,
+                api_url=api_url,
+                api_key=api_key,
+                messages=[],  # Clean slate - no history noise
+                npc=None,  # No system prompt with tool descriptions
+                team=None,
+                images=generated_images or None,
+                format="json",
+            )
+        else:
+            prompt = f"""Request: {original_command}
 
 Available Tools:
 {jinx_list}
 
 Instructions:
-1. Analyze the request and determine the best tool to use
-2. If you have enough information to answer, use {{"action": "answer", "response": "your answer"}}
-3. If you need to use a tool, use {{"action": "jinx", "jinx_name": "tool_name", "inputs": {{"param": "value"}}}}
-4. Use EXACT parameter names from tool definitions
-5. Do NOT repeat the same tool call with the same inputs{history_text}"""
+1. If you can answer directly without tools, use {{"action": "answer", "response": "your answer"}}
+2. If you need to use a tool, use {{"action": "jinx", "jinx_name": "tool_name", "inputs": {{"param": "value"}}}}
+3. Use EXACT parameter names from tool definitions"""
 
-        if context:
-            prompt += f"\n\nCurrent context: {context}"
+            if context:
+                prompt += f"\n\nCurrent context: {context}"
 
-        response = get_llm_response(
-            prompt,
-            model=model,
-            provider=provider,
-            api_url=api_url,
-            api_key=api_key,
-            messages=current_messages[-10:],
-            npc=npc,
-            team=team,
-            images=((images or []) if iteration == 0 else []) + generated_images or None,
-            format="json",
-            context=context,
-        )
+            response = get_llm_response(
+                prompt,
+                model=model,
+                provider=provider,
+                api_url=api_url,
+                api_key=api_key,
+                messages=current_messages[-10:],
+                npc=npc,
+                team=team,
+                images=((images or []) if iteration == 0 else []) + generated_images or None,
+                format="json",
+                context=context,
+            )
 
         if response.get("usage"):
             total_usage["input_tokens"] += response["usage"].get("input_tokens", 0)
@@ -726,17 +743,16 @@ Instructions:
         decision = response.get("response", {})
         logger.debug(f"[_react_fallback] Raw decision: {str(decision)[:200]}")
 
-        # Handle None response - model decided no action needed
-        if decision is None:
-            logger.debug(f"[_react_fallback] Decision is None, returning current output")
-            return {"messages": current_messages, "output": "", "usage": total_usage, "jinx_executions": jinx_executions}
-
-        if isinstance(decision, str):
-            try:
-                decision = json.loads(decision)
-            except:
-                logger.debug(f"[_react_fallback] Could not parse JSON, returning as text")
-                return {"messages": current_messages, "output": decision, "usage": total_usage, "jinx_executions": jinx_executions}
+        if not isinstance(decision, dict):
+            logger.debug(f"[_react_fallback] Non-dict response on iteration {iteration} - continuing")
+            # If we already have tool results and model can't produce valid JSON answer,
+            # just return the last tool result directly
+            if jinx_executions:
+                last_output = jinx_executions[-1].get("output", "")
+                logger.debug(f"[_react_fallback] Forcing answer from last tool result")
+                return {"messages": current_messages, "output": str(last_output), "usage": total_usage, "jinx_executions": jinx_executions}
+            context = f"Your response was not valid JSON object. You must respond with a JSON object: either {{\"action\": \"answer\", \"response\": \"...\"}} or {{\"action\": \"jinx\", \"jinx_name\": \"tool_name\", \"inputs\": {{...}}}}"
+            continue
 
         logger.debug(f"[_react_fallback] Parsed decision action: {decision.get('action') if decision else 'None'}")
         if decision.get("action") == "answer":
@@ -784,6 +800,13 @@ Instructions:
                 inputs = {k: v for k, v in decision.items() if k not in ('action', 'jinx_name', 'inputs', 'response')}
             logger.debug(f"[_react_fallback] Jinx action: {jinx_name} with inputs: {inputs}")
 
+            # If we already have tool results and model tries to call another tool,
+            # force-return the existing result instead of executing more tools
+            if jinx_executions:
+                last_output = jinx_executions[-1].get("output", "")
+                logger.debug(f"[_react_fallback] Model tried to call '{jinx_name}' after already having results - forcing answer")
+                return {"messages": current_messages, "output": str(last_output), "usage": total_usage, "jinx_executions": jinx_executions}
+
             if jinx_name not in jinxs:
                 context = f"Error: '{jinx_name}' not found. Available: {list(jinxs.keys())}"
                 logger.debug(f"[_react_fallback] Jinx not found: {jinx_name}")
@@ -851,41 +874,20 @@ Instructions:
             # Truncate output for context to avoid sending huge base64 data back to LLM
             output_for_context = str(output)[:8000] + "..." if len(str(output)) > 8000 else str(output)
             context = f"Tool '{jinx_name}' returned: {output_for_context}"
-            command = f"{command}\n\nPrevious: {context}"
 
         else:
-            logger.debug(f"[_react_fallback] Unknown action - returning {len(current_messages)} messages")
-            # If we have jinx executions, return the last output instead of empty decision
-            if jinx_executions and jinx_executions[-1].get("output"):
-                return {"messages": current_messages, "output": jinx_executions[-1]["output"], "usage": total_usage, "jinx_executions": jinx_executions}
-            # If decision is empty {}, retry with clearer prompt if jinxs are available
-            if not decision or decision == {}:
-                if jinxs and iteration < max_iterations - 1:
-                    # Retry with explicit instruction to use a jinx
-                    context = f"You MUST use one of these tools to complete the task: {list(jinxs.keys())}. Return JSON with action and inputs."
-                    continue
-                else:
-                    # Last resort: get a text response
-                    pass
-                    current_messages.append({"role": "user", "content": command})
-                    fallback_response = get_llm_response(
-                        command,
-                        model=model,
-                        provider=provider,
-                        messages=current_messages[-10:],
-                        npc=npc,
-                        team=team,
-                        stream=stream,
-                        context=context,
-                    )
-                    if fallback_response.get("usage"):
-                        total_usage["input_tokens"] += fallback_response["usage"].get("input_tokens", 0)
-                        total_usage["output_tokens"] += fallback_response["usage"].get("output_tokens", 0)
-                    output = fallback_response.get("response", "")
-                    if output and isinstance(output, str):
-                        current_messages.append({"role": "assistant", "content": output})
-                    return {"messages": current_messages, "output": output, "usage": total_usage, "jinx_executions": jinx_executions}
-            return {"messages": current_messages, "output": str(decision), "usage": total_usage, "jinx_executions": jinx_executions}
+            # Unknown or missing action
+            action_val = decision.get("action")
+            logger.debug(f"[_react_fallback] Unknown action '{action_val}' on iteration {iteration}")
+            # If we have tool results, just return them
+            if jinx_executions:
+                last_output = jinx_executions[-1].get("output", "")
+                return {"messages": current_messages, "output": str(last_output), "usage": total_usage, "jinx_executions": jinx_executions}
+            if jinxs:
+                context = f"Your response had action='{action_val}' which is not valid. You must respond with either {{\"action\": \"answer\", \"response\": \"...\"}} or {{\"action\": \"jinx\", \"jinx_name\": \"tool_name\", \"inputs\": {{...}}}}. Available tools: {list(jinxs.keys())}"
+            else:
+                context = f"Your response had action='{action_val}' which is not valid. Respond with {{\"action\": \"answer\", \"response\": \"your final answer\"}}"
+            continue
 
     logger.debug(f"[_react_fallback] Max iterations - returning {len(current_messages)} messages")
     # If we have jinx executions, return the last output

npcpy/memory/command_history.py

@@ -650,7 +650,11 @@ class CommandHistory:
             Column('timestamp', String(50)),
             Column('npc', String(100)),
             Column('team', String(100)),
-            Column('conversation_id', String(100))
+            Column('conversation_id', String(100)),
+            Column('output', Text),
+            Column('status', String(50)),
+            Column('error_message', Text),
+            Column('duration_ms', Integer)
         )
         
         Table('npc_executions', metadata,
@@ -706,6 +710,22 @@ class CommandHistory:
                     conn.execute(text("ALTER TABLE conversation_history ADD COLUMN cost VARCHAR(50)"))
                 except Exception:
                     pass  # Column already exists
+                # jinx_executions new columns
+                for col in [
+                    "ALTER TABLE jinx_executions ADD COLUMN output TEXT",
+                    "ALTER TABLE jinx_executions ADD COLUMN status VARCHAR(50)",
+                    "ALTER TABLE jinx_executions ADD COLUMN error_message TEXT",
+                    "ALTER TABLE jinx_executions ADD COLUMN duration_ms INTEGER",
+                ]:
+                    try:
+                        conn.execute(text(col))
+                    except Exception:
+                        pass
+                # drop the redundant jinx_execution_log if it exists
+                try:
+                    conn.execute(text("DROP TABLE IF EXISTS jinx_execution_log"))
+                except Exception:
+                    pass
 
     def _setup_execution_triggers(self):
         if 'sqlite' in str(self.engine.url):
@@ -1028,40 +1048,45 @@ class CommandHistory:
         return self._fetch_all(stmt, params)
 
     def get_memory_examples_for_context(self, npc: str, team: str, directory_path: str,
-                                    n_approved: int = 10, n_rejected: int = 10):
-        """Get recent approved and rejected memories for learning context"""
-        
-        approved_stmt = """
+                                    n_approved: int = 10, n_rejected: int = 10, n_edited: int = 5):
+        """Get recent approved, rejected, and edited memories for learning context."""
+
+        scope_order = """
+            CASE WHEN npc = :npc AND team = :team AND directory_path = :path THEN 1
+                 WHEN npc = :npc AND team = :team THEN 2
+                 WHEN team = :team THEN 3
+                 ELSE 4 END
+        """
+
+        approved_stmt = f"""
             SELECT initial_memory, final_memory, status FROM memory_lifecycle
             WHERE status IN ('human-approved', 'model-approved')
-            ORDER BY 
-                CASE WHEN npc = :npc AND team = :team AND directory_path = :path THEN 1
-                    WHEN npc = :npc AND team = :team THEN 2  
-                    WHEN team = :team THEN 3
-                    ELSE 4 END,
-                created_at DESC
+            ORDER BY {scope_order}, created_at DESC
             LIMIT :n_approved
         """
-        
-        rejected_stmt = """
+
+        rejected_stmt = f"""
             SELECT initial_memory, status FROM memory_lifecycle
             WHERE status IN ('human-rejected', 'model-rejected')
-            ORDER BY 
-                CASE WHEN npc = :npc AND team = :team AND directory_path = :path THEN 1
-                    WHEN npc = :npc AND team = :team THEN 2
-                    WHEN team = :team THEN 3  
-                    ELSE 4 END,
-                created_at DESC
+            ORDER BY {scope_order}, created_at DESC
             LIMIT :n_rejected
         """
-        
-        params = {"npc": npc, "team": team, "path": directory_path, 
-                "n_approved": n_approved, "n_rejected": n_rejected}
-        
+
+        edited_stmt = f"""
+            SELECT initial_memory, final_memory, status FROM memory_lifecycle
+            WHERE status = 'human-edited' AND final_memory IS NOT NULL
+            ORDER BY {scope_order}, created_at DESC
+            LIMIT :n_edited
+        """
+
+        params = {"npc": npc, "team": team, "path": directory_path,
+                "n_approved": n_approved, "n_rejected": n_rejected, "n_edited": n_edited}
+
         approved = self._fetch_all(approved_stmt, params)
         rejected = self._fetch_all(rejected_stmt, params)
-        
-        return {"approved": approved, "rejected": rejected}
+        edited = self._fetch_all(edited_stmt, params)
+
+        return {"approved": approved, "rejected": rejected, "edited": edited}
 
     def get_pending_memories(self, limit: int = 50):
         """Get memories pending human approval"""
@@ -1133,25 +1158,26 @@ class CommandHistory:
             conn.execute(text(stmt), params)
 
     def save_jinx_execution(
-        self, 
-        triggering_message_id: str, 
-        conversation_id: str, 
+        self,
+        triggering_message_id: str,
+        conversation_id: str,
         npc_name: Optional[str],
-        jinx_name: str, 
-        jinx_inputs: Dict, 
-        jinx_output: Any, status: str,
-        team_name: Optional[str] = None, 
+        jinx_name: str,
+        jinx_inputs: Dict,
+        jinx_output: Any,
+        status: str,
+        team_name: Optional[str] = None,
         error_message: Optional[str] = None,
-        response_message_id: Optional[str] = None, 
+        response_message_id: Optional[str] = None,
         duration_ms: Optional[int] = None
     ):
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
+
         try:
             inputs_json = json.dumps(jinx_inputs, cls=CustomJSONEncoder)
         except TypeError:
             inputs_json = json.dumps(str(jinx_inputs))
-        
+
         try:
             if isinstance(jinx_output, (str, int, float, bool, list, dict, type(None))):
                 outputs_json = json.dumps(jinx_output, cls=CustomJSONEncoder)
@@ -1160,29 +1186,32 @@ class CommandHistory:
         except TypeError:
             outputs_json = json.dumps(f"Non-serializable output: {type(jinx_output)}")
 
+        msg_id = triggering_message_id or f"jinx-{jinx_name}-{timestamp.replace(' ', '-')}"
+
+        # If trigger already created a row, update it; otherwise insert
         stmt = """
-            INSERT INTO jinx_execution_log
-            (triggering_message_id, conversation_id, timestamp, npc_name, team_name,
-             jinx_name, jinx_inputs, jinx_output, status, error_message, response_message_id, duration_ms)
-             VALUES (:triggering_message_id, :conversation_id, :timestamp, :npc_name, :team_name,
-                     :jinx_name, :jinx_inputs, :jinx_output, :status, :error_message, :response_message_id, :duration_ms)
+            INSERT OR REPLACE INTO jinx_executions
+            (message_id, jinx_name, input, timestamp, npc, team,
+             conversation_id, output, status, error_message, duration_ms)
+            VALUES (:message_id, :jinx_name, :input, :timestamp, :npc, :team,
+                    :conversation_id, :output, :status, :error_message, :duration_ms)
         """
         params = {
-            "triggering_message_id": triggering_message_id,
-            "conversation_id": conversation_id,
-            "timestamp": timestamp,
-            "npc_name": npc_name,
-            "team_name": team_name,
+            "message_id": msg_id,
             "jinx_name": jinx_name,
-            "jinx_inputs": inputs_json,
-            "jinx_output": outputs_json,
+            "input": inputs_json,
+            "timestamp": timestamp,
+            "npc": npc_name,
+            "team": team_name,
+            "conversation_id": conversation_id,
+            "output": outputs_json,
             "status": status,
             "error_message": error_message,
-            "response_message_id": response_message_id,
-            "duration_ms": duration_ms
+            "duration_ms": duration_ms,
         }
-        
-        return self._execute_returning_id(stmt, params)
+
+        with self.engine.begin() as conn:
+            conn.execute(text(stmt), params)
 
     def get_full_message_content(self, message_id):
         stmt = "SELECT content FROM conversation_history WHERE message_id = :message_id ORDER BY timestamp ASC"
@@ -1494,28 +1523,47 @@ def start_new_conversation(prepend: str = None) -> str:
 def format_memory_context(memory_examples):
     if not memory_examples:
         return ""
-    
-    context_parts = []
-    
+
     approved_examples = memory_examples.get("approved", [])
     rejected_examples = memory_examples.get("rejected", [])
-    
+    edited_examples = memory_examples.get("edited", [])
+
+    if not approved_examples and not rejected_examples and not edited_examples:
+        return ""
+
+    parts = ["MEMORY QUALITY GUIDELINES (based on user feedback):"]
+
     if approved_examples:
-        context_parts.append("EXAMPLES OF GOOD MEMORIES:")
-        for ex in approved_examples[:5]:
-            final = ex.get("final_memory") or ex.get("initial_memory")
-            context_parts.append(f"- {final}")
-    
+        parts.append("\nAPPROVED — memories like these were kept:")
+        for ex in approved_examples[:7]:
+            mem = ex.get("final_memory") or ex.get("initial_memory")
+            parts.append(f"  + {mem}")
+
+    if edited_examples:
+        parts.append("\nCORRECTED — the user fixed these (learn from the corrections):")
+        for ex in edited_examples[:5]:
+            original = ex.get("initial_memory", "")
+            corrected = ex.get("final_memory", "")
+            if original and corrected and original != corrected:
+                parts.append(f"  BEFORE: {original}")
+                parts.append(f"  AFTER:  {corrected}")
+                parts.append("")
+
     if rejected_examples:
-        context_parts.append("\nEXAMPLES OF POOR MEMORIES TO AVOID:")
-        for ex in rejected_examples[:3]:
-            context_parts.append(f"- {ex.get('initial_memory')}")
-    
-    if context_parts:
-        context_parts.append("\nLearn from these examples to generate similar high-quality memories.")
-        return "\n".join(context_parts)
-    
-    return ""
+        parts.append("\nREJECTED — memories like these were thrown out (do NOT generate similar ones):")
+        for ex in rejected_examples[:5]:
+            parts.append(f"  x {ex.get('initial_memory')}")
+
+    parts.append("\nRULES derived from this feedback:")
+    parts.append("- Match the style and specificity of approved memories.")
+    if edited_examples:
+        parts.append("- Apply the same corrections the user made in the CORRECTED examples.")
+    if rejected_examples:
+        parts.append("- Avoid the patterns seen in rejected memories.")
+    parts.append("- Each memory must be self-contained: no vague pronouns (this, that, it) without referents.")
+    parts.append("- Do not duplicate or closely paraphrase any existing approved memory.")
+
+    return "\n".join(parts)
 def save_conversation_message(
     command_history: CommandHistory,
     conversation_id: str,