npcpy 1.3.2__tar.gz → 1.3.4__tar.gz

{npcpy-1.3.2/npcpy.egg-info → npcpy-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.2
+Version: 1.3.4
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.3.2 → npcpy-1.3.4}/npcpy/ft/diff.py

@@ -3,7 +3,7 @@ try:
     import torch.nn as nn
     import torch.nn.functional as F
     from torch.utils.data import DataLoader, Dataset as TorchDataset
-    from transformers import CLIPTextModel, CLIPTokenizer
+
     TORCH_AVAILABLE = True
 except ImportError:
     torch = None

{npcpy-1.3.2 → npcpy-1.3.4}/npcpy/gen/response.py

@@ -297,6 +297,16 @@ def get_ollama_response(
             last_user_idx = len(messages) - 1
         messages[last_user_idx]["images"] = image_paths
 
+    # Ollama's pydantic model requires tool_calls arguments to be dicts, not strings
+    for msg in messages:
+        if msg.get("tool_calls"):
+            for tc in msg["tool_calls"]:
+                if tc.get("function") and isinstance(tc["function"].get("arguments"), str):
+                    try:
+                        tc["function"]["arguments"] = json.loads(tc["function"]["arguments"])
+                    except (json.JSONDecodeError, TypeError):
+                        tc["function"]["arguments"] = {}
+
     api_params = {
         "model": model,
         "messages": messages,
@@ -387,7 +397,7 @@ def get_ollama_response(
             return result
 
     
-    
+    print('Debug', api_params)
     res = ollama.chat(**api_params, options=options)
     result["raw_response"] = res
     

{npcpy-1.3.2 → npcpy-1.3.4}/npcpy/llm_funcs.py

@@ -14,6 +14,8 @@ from npcpy.npc_sysenv import (
     request_user_input, 
     get_system_message
 )
+
+
 from npcpy.gen.response import get_litellm_response
 from npcpy.gen.image_gen import generate_image
 from npcpy.gen.video_gen import generate_video_diffusers, generate_video_veo3
@@ -216,7 +218,7 @@ def get_llm_response(
 
     def _context_suffix(ctx):
         if ctx is not None:
-            return f'User Provided Context: {ctx}'
+            return f'\n\n\nUser Provided Context: {ctx}'
         return ''
 
     def _build_messages(base_messages, sys_msg, prompt_text, ctx_suffix):
@@ -564,6 +566,7 @@ def check_llm_command(
     extra_globals=None,
     max_iterations: int = 5,
     jinxs: Dict = None,
+    tool_capable: bool = None,  # If None, will be auto-detected
 ):
     """
     Simple agent loop: try tool calling first, fall back to ReAct if unsupported.
@@ -571,27 +574,21 @@ def check_llm_command(
     if messages is None:
         messages = []
 
-    # Log incoming messages
-    import logging
-    logger = logging.getLogger("npcpy.llm_funcs")
-    logger.debug(f"[check_llm_command] Received {len(messages)} messages")
-    for i, msg in enumerate(messages[-5:]):  # Log last 5 messages
-        role = msg.get('role', 'unknown')
-        content = msg.get('content', '')
-        content_preview = content[:100] if isinstance(content, str) else str(type(content))
-        logger.debug(f"  [{i}] role={role}, content_preview={content_preview}...")
-
     total_usage = {"input_tokens": 0, "output_tokens": 0}
+
     # Use provided jinxs or get from npc/team
     if jinxs is None:
         jinxs = _get_jinxs(npc, team)
-    tools = _jinxs_to_tools(jinxs) if jinxs else None
+
+    # Only prepare tools if model supports them
+    tools = None
+    if tool_capable is not False and jinxs:
+        tools = _jinxs_to_tools(jinxs)
 
     # Keep full message history, only truncate for API calls to reduce tokens
     full_messages = messages.copy() if messages else []
-    logger.debug(f"[check_llm_command] full_messages initialized with {len(full_messages)} messages")
 
-    # Try with native tool calling first
+    # Make LLM call (with or without tools based on tool_capable)
 
     try:
         response = get_llm_response(
@@ -609,7 +606,7 @@ def check_llm_command(
             tools=tools,
         )
     except Exception as e:
-        print(colored(f"[check_llm_command] EXCEPTION in get_llm_response: {type(e).__name__}: {e}", "red"))
+        print(f"[check_llm_command] EXCEPTION in get_llm_response: {type(e).__name__}: {e}", "red")
         return {
             "messages": full_messages,
             "output": f"LLM call failed: {e}",
@@ -617,8 +614,6 @@ def check_llm_command(
             "usage": total_usage,
         }
 
-    if response.get("error"):
-        logger.warning(f"[check_llm_command] Error in response: {response.get('error')}")
 
     if response.get("usage"):
         total_usage["input_tokens"] += response["usage"].get("input_tokens", 0)
@@ -634,7 +629,6 @@ def check_llm_command(
         # For streaming, the caller (process_result) handles appending after consumption
         if assistant_response and isinstance(assistant_response, str):
             full_messages.append({"role": "assistant", "content": assistant_response})
-        logger.debug(f"[check_llm_command] No tool calls - returning {len(full_messages)} messages")
         return {
             "messages": full_messages,
             "output": assistant_response,
@@ -670,8 +664,7 @@ def check_llm_command(
         assistant_msg["tool_calls"] = _serialize_tool_calls(tool_calls)
     full_messages.append(assistant_msg)
     current_messages = full_messages
-    logger.debug(f"[check_llm_command] Tool calls detected - current_messages has {len(current_messages)} messages")
-    for iteration in range(max_iterations):
+    for _ in range(max_iterations):
         for tc in tool_calls:
             # Handle both dict and object formats
             if hasattr(tc, 'function'):
@@ -692,15 +685,12 @@ def check_llm_command(
 
             if jinx_name in jinxs:
                 try:
-                    from termcolor import colored
-                    print(colored(f"  ⚡ {jinx_name}", "cyan"), end="", flush=True)
+
+                    print((f"  ⚡ {jinx_name}", "cyan"), end="", flush=True)
                 except:
                     pass
                 output = _execute_jinx(jinxs[jinx_name], inputs, npc, team, current_messages, extra_globals)
-                try:
-                    print(colored(" ✓", "green"), flush=True)
-                except:
-                    pass
+
 
                 # Add tool result to messages
                 # Include name for Gemini compatibility
@@ -745,8 +735,6 @@ def check_llm_command(
             )
         except Exception as e:
             # If continuation fails, return what we have so far
-            # The tool was already executed successfully
-            logger.warning(f"[check_llm_command] Continuation failed: {e}")
             return {
                 "messages": current_messages,
                 "output": f"Tool executed successfully. (Continuation error: {type(e).__name__})",
@@ -767,14 +755,12 @@ def check_llm_command(
 
         if not tool_calls:
             # Done - return full message history
-            logger.debug(f"[check_llm_command] Tool loop done - returning {len(current_messages)} messages")
             return {
                 "messages": current_messages,
                 "output": assistant_response,
                 "usage": total_usage,
             }
 
-    logger.debug(f"[check_llm_command] Max iterations - returning {len(current_messages)} messages")
     return {
         "messages": current_messages,
         "output": response.get("response", "Max iterations reached"),
@@ -867,16 +853,11 @@ Use EXACT parameter names from the tool definitions above."""
                 context = f"Error: '{jinx_name}' not found. Available: {list(jinxs.keys())}"
                 continue
 
-            try:
-                from termcolor import colored
-                print(colored(f"  ⚡ {jinx_name}", "cyan"), end="", flush=True)
-            except:
-                pass
+
+
             output = _execute_jinx(jinxs[jinx_name], inputs, npc, team, current_messages, extra_globals)
-            try:
-                print(colored(" ✓", "green"), flush=True)
-            except:
-                pass
+
+
             context = f"Tool '{jinx_name}' returned: {output}"
             command = f"{command}\n\nPrevious: {context}"
 

{npcpy-1.3.2 → npcpy-1.3.4}/npcpy/memory/command_history.py

@@ -487,7 +487,10 @@ class CommandHistory:
             Column('model', String(100)),
             Column('provider', String(100)),
             Column('npc', String(100)),
-            Column('team', String(100))
+            Column('team', String(100)),
+            Column('reasoning_content', Text),  # For thinking tokens / chain of thought
+            Column('tool_calls', Text),  # JSON array of tool calls made by assistant
+            Column('tool_results', Text)  # JSON array of tool call results
         )
         
         Table('message_attachments', metadata,
@@ -719,31 +722,41 @@ class CommandHistory:
 
 
     def add_conversation(
-        self, 
+        self,
         message_id,
         timestamp,
-        role, 
-        content, 
-        conversation_id, 
+        role,
+        content,
+        conversation_id,
         directory_path,
-        model=None, 
-        provider=None, 
-        npc=None, 
+        model=None,
+        provider=None,
+        npc=None,
         team=None,
         attachments=None,
+        reasoning_content=None,
+        tool_calls=None,
+        tool_results=None,
     ):
         if isinstance(content, (dict, list)):
             content = json.dumps(content, cls=CustomJSONEncoder)
 
+        # Serialize tool_calls and tool_results as JSON
+        if tool_calls is not None and not isinstance(tool_calls, str):
+            tool_calls = json.dumps(tool_calls, cls=CustomJSONEncoder)
+        if tool_results is not None and not isinstance(tool_results, str):
+            tool_results = json.dumps(tool_results, cls=CustomJSONEncoder)
+
         stmt = """
             INSERT INTO conversation_history
-            (message_id, timestamp, role, content, conversation_id, directory_path, model, provider, npc, team)
-            VALUES (:message_id, :timestamp, :role, :content, :conversation_id, :directory_path, :model, :provider, :npc, :team)
+            (message_id, timestamp, role, content, conversation_id, directory_path, model, provider, npc, team, reasoning_content, tool_calls, tool_results)
+            VALUES (:message_id, :timestamp, :role, :content, :conversation_id, :directory_path, :model, :provider, :npc, :team, :reasoning_content, :tool_calls, :tool_results)
         """
         params = {
             "message_id": message_id, "timestamp": timestamp, "role": role, "content": content,
             "conversation_id": conversation_id, "directory_path": directory_path, "model": model,
-            "provider": provider, "npc": npc, "team": team
+            "provider": provider, "npc": npc, "team": team, "reasoning_content": reasoning_content,
+            "tool_calls": tool_calls, "tool_results": tool_results
         }
         with self.engine.begin() as conn:
             conn.execute(text(stmt), params)
@@ -756,7 +769,7 @@ class CommandHistory:
                     attachment_type=attachment.get("type"),
                     data=attachment.get("data"),
                     size=attachment.get("size"),
-                    file_path=attachment.get("path") 
+                    file_path=attachment.get("path")
                 )
 
         return message_id
@@ -1084,16 +1097,28 @@ class CommandHistory:
     def get_conversations_by_id(self, conversation_id: str) -> List[Dict[str, Any]]:
         stmt = """
             SELECT id, message_id, timestamp, role, content, conversation_id,
-                    directory_path, model, provider, npc, team
-            FROM conversation_history WHERE conversation_id = :conversation_id 
+                    directory_path, model, provider, npc, team,
+                    reasoning_content, tool_calls, tool_results
+            FROM conversation_history WHERE conversation_id = :conversation_id
             ORDER BY timestamp ASC
         """
         results = self._fetch_all(stmt, {"conversation_id": conversation_id})
-        
+
         for message_dict in results:
             attachments = self.get_message_attachments(message_dict["message_id"])
             if attachments:
                 message_dict["attachments"] = attachments
+            # Parse JSON fields
+            if message_dict.get("tool_calls"):
+                try:
+                    message_dict["tool_calls"] = json.loads(message_dict["tool_calls"])
+                except (json.JSONDecodeError, TypeError):
+                    pass
+            if message_dict.get("tool_results"):
+                try:
+                    message_dict["tool_results"] = json.loads(message_dict["tool_results"])
+                except (json.JSONDecodeError, TypeError):
+                    pass
         return results
 
     def get_npc_conversation_stats(self, start_date=None, end_date=None) -> pd.DataFrame:
@@ -1295,9 +1320,13 @@ def save_conversation_message(
     team: str = None,
     attachments: List[Dict] = None,
     message_id: str = None,
+    reasoning_content: str = None,
+    tool_calls: List[Dict] = None,
+    tool_results: List[Dict] = None,
     ):
     """
     Saves a conversation message linked to a conversation ID with optional attachments.
+    Now also supports reasoning_content, tool_calls, and tool_results.
     """
     if wd is None:
         wd = os.getcwd()
@@ -1307,17 +1336,20 @@ def save_conversation_message(
 
 
     return command_history.add_conversation(
-        message_id, 
-        timestamp, 
-        role, 
-        content, 
-        conversation_id, 
-        wd, 
-        model=model, 
-        provider=provider, 
-        npc=npc, 
-        team=team, 
-        attachments=attachments)
+        message_id,
+        timestamp,
+        role,
+        content,
+        conversation_id,
+        wd,
+        model=model,
+        provider=provider,
+        npc=npc,
+        team=team,
+        attachments=attachments,
+        reasoning_content=reasoning_content,
+        tool_calls=tool_calls,
+        tool_results=tool_results)
 def retrieve_last_conversation(
     command_history: CommandHistory, conversation_id: str
     ) -> str: