npcpy 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

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/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/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/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:

npcpy/serve.py

@@ -216,12 +216,14 @@ class MCPClientNPC:
             self._exit_stack = None
 
 
-def get_llm_response_with_handling(prompt, npc, messages, tools, stream, team, context=None):
+def get_llm_response_with_handling(prompt, npc,model, provider, messages, tools, stream, team, context=None):
     """Unified LLM response with basic exception handling (inlined from corca to avoid that dependency)."""
     try:
         return get_llm_response(
             prompt=prompt,
             npc=npc,
+            model=model, 
+            provider=provider,
             messages=messages,
             tools=tools,
             auto_process_tool_calls=False,
@@ -234,6 +236,8 @@ def get_llm_response_with_handling(prompt, npc, messages, tools, stream, team, c
         return get_llm_response(
             prompt=prompt,
             npc=npc,
+            model=model, 
+            provider=provider,
             messages=messages,
             tools=tools,
             auto_process_tool_calls=False,
@@ -241,6 +245,7 @@ def get_llm_response_with_handling(prompt, npc, messages, tools, stream, team, c
             team=team,
             context=context
         )
+    
 class MCPServerManager:
     """
     Simple in-process tracker for launching/stopping MCP servers.
@@ -2920,11 +2925,7 @@ def get_mcp_tools():
     )
     server_path = os.path.abspath(os.path.expanduser(resolved_path))
 
-    try:
-        from npcsh.corca import MCPClientNPC
-    except ImportError:
-        return jsonify({"error": "MCP Client (npcsh.corca) not available. Ensure npcsh.corca is installed and importable."}), 500
-
+    # MCPClientNPC is defined inline at the top of this file
     temp_mcp_client = None
     jinx_tools = []
     try:
@@ -3473,61 +3474,6 @@ def stream():
             **tool_args
         )
         messages = stream_response.get('messages', messages)
-
-    elif exe_mode == 'npcsh':
-        from npcsh._state import execute_command, initial_state
-        from npcsh.routes import router
-        initial_state.model = model
-        initial_state.provider = provider
-        initial_state.npc = npc_object
-        initial_state.team = team_object
-        initial_state.messages = messages
-        initial_state.command_history = command_history
-        
-        state, stream_response = execute_command(
-            commandstr, 
-            initial_state, router=router)
-        messages = state.messages        
-        
-    elif exe_mode == 'guac':
-        from npcsh.guac import execute_guac_command
-        from npcsh.routes import router
-        from npcsh._state import initial_state
-        from pathlib import Path
-        import pandas as pd, numpy as np, matplotlib.pyplot as plt
-
-        if not hasattr(app, 'guac_locals'):
-            app.guac_locals = {}
-
-        if conversation_id not in app.guac_locals:
-            app.guac_locals[conversation_id] = {
-                'pd': pd, 
-                'np': np, 
-                'plt': plt, 
-                'datetime': datetime,
-                'Path': Path, 
-                'os': os, 
-                'sys': sys, 
-                'json': json
-            }
-
-        initial_state.model = model
-        initial_state.provider = provider  
-        initial_state.npc = npc_object
-        initial_state.team = team_object
-        initial_state.messages = messages
-        initial_state.command_history = command_history
-        
-        state, stream_response = execute_guac_command(
-            commandstr,
-            initial_state, 
-            app.guac_locals[conversation_id],
-            "guac",
-            Path.cwd() / "npc_team", 
-            router
-        )
-        messages = state.messages
-        
     elif exe_mode == 'tool_agent':
         mcp_server_path_from_request = data.get("mcpServerPath")
         selected_mcp_tools_from_request = data.get("selectedMcpTools", [])
@@ -3576,7 +3522,6 @@ def stream():
 
         mcp_client = app.mcp_clients[state_key]["client"]
         messages = app.mcp_clients[state_key].get("messages", messages)
-
         def stream_mcp_sse():
             nonlocal messages
             iteration = 0
@@ -3599,17 +3544,21 @@ def stream():
                 llm_response = get_llm_response_with_handling(
                     prompt=prompt,
                     npc=npc_object,
+                    model=model, 
+                    provider=provider,
                     messages=messages,
                     tools=tools_for_llm,
                     stream=True,
                     team=team_object,
                     context=f' The users working directory is {current_path}'
                 )
+                print('RESPONSE', llm_response)
 
                 stream = llm_response.get("response", [])
                 messages = llm_response.get("messages", messages)
                 collected_content = ""
                 collected_tool_calls = []
+                agent_tool_call_data = {"id": None, "function_name": None, "arguments": ""}
 
                 for response_chunk in stream:
                     with cancellation_lock:
@@ -3617,7 +3566,62 @@ def stream():
                             yield {"type": "interrupt"}
                             return
 
-                    if hasattr(response_chunk, "choices") and response_chunk.choices:
+                    if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
+                        # Ollama returns ChatResponse objects - support both attribute and dict access
+                        msg = getattr(response_chunk, "message", None) or (response_chunk.get("message", {}) if hasattr(response_chunk, "get") else {})
+                        chunk_content = getattr(msg, "content", None) or (msg.get("content") if hasattr(msg, "get") else "") or ""
+                        # Extract Ollama thinking/reasoning tokens
+                        reasoning_content = getattr(msg, "thinking", None) or (msg.get("thinking") if hasattr(msg, "get") else None)
+                        # Handle tool calls with robust attribute/dict access
+                        tool_calls = getattr(msg, "tool_calls", None) or (msg.get("tool_calls") if hasattr(msg, "get") else None)
+                        if tool_calls:
+                            for tool_call in tool_calls:
+                                tc_id = getattr(tool_call, "id", None) or (tool_call.get("id") if hasattr(tool_call, "get") else None)
+                                tc_func = getattr(tool_call, "function", None) or (tool_call.get("function") if hasattr(tool_call, "get") else None)
+                                if tc_func:
+                                    tc_name = getattr(tc_func, "name", None) or (tc_func.get("name") if hasattr(tc_func, "get") else None)
+                                    tc_args = getattr(tc_func, "arguments", None) or (tc_func.get("arguments") if hasattr(tc_func, "get") else None)
+                                    if tc_name:
+                                        arg_str = tc_args
+                                        if isinstance(arg_str, dict):
+                                            arg_str = json.dumps(arg_str)
+                                        elif arg_str is None:
+                                            arg_str = "{}"
+                                        # Add to collected_tool_calls for Ollama
+                                        collected_tool_calls.append({
+                                            "id": tc_id or f"call_{len(collected_tool_calls)}",
+                                            "type": "function",
+                                            "function": {"name": tc_name, "arguments": arg_str}
+                                        })
+                        if chunk_content:
+                            collected_content += chunk_content
+                        # Extract other fields with robust access
+                        created_at = getattr(response_chunk, "created_at", None) or (response_chunk.get("created_at") if hasattr(response_chunk, "get") else None)
+                        model_name = getattr(response_chunk, "model", None) or (response_chunk.get("model") if hasattr(response_chunk, "get") else model)
+                        msg_role = getattr(msg, "role", None) or (msg.get("role") if hasattr(msg, "get") else "assistant")
+                        done_reason = getattr(response_chunk, "done_reason", None) or (response_chunk.get("done_reason") if hasattr(response_chunk, "get") else None)
+
+                        # Build chunk_data with proper structure
+                        chunk_data = {
+                            "id": None,
+                            "object": None,
+                            "created": str(created_at) if created_at else datetime.datetime.now().isoformat(),
+                            "model": model_name,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {
+                                        "content": chunk_content,
+                                        "role": msg_role,
+                                        "reasoning_content": reasoning_content
+                                    },
+                                    "finish_reason": done_reason
+                                }
+                            ]
+                        }
+                        yield chunk_data
+
+                    elif hasattr(response_chunk, "choices") and response_chunk.choices:
                         delta = response_chunk.choices[0].delta
                         if hasattr(delta, "content") and delta.content:
                             collected_content += delta.content
@@ -3698,55 +3702,41 @@ def stream():
                             try:
                                 jinx_ctx = jinx_obj.execute(
                                     input_values=tool_args if isinstance(tool_args, dict) else {},
-                                    npc=npc_object,
-                                    messages=messages
+                                    npc=npc_object
                                 )
-                                tool_content = str(jinx_ctx.get("output", jinx_ctx))
-                                print(f"[MCP] jinx tool_complete {tool_name}")
+                                tool_content = str(jinx_ctx)
                             except Exception as e:
-                                raise Exception(f"Jinx execution failed: {e}")
+                                tool_content = f"Jinx execution error: {str(e)}"
                         else:
-                            try:
-                                loop = asyncio.get_event_loop()
-                            except RuntimeError:
-                                loop = asyncio.new_event_loop()
-                                asyncio.set_event_loop(loop)
-                            if loop.is_closed():
-                                loop = asyncio.new_event_loop()
-                                asyncio.set_event_loop(loop)
-                            mcp_result = loop.run_until_complete(
-                                mcp_client.session.call_tool(tool_name, tool_args)
-                            ) if mcp_client else {"error": "No MCP client"}
-                            if hasattr(mcp_result, "content") and mcp_result.content:
-                                for content_item in mcp_result.content:
-                                    if hasattr(content_item, "text"):
-                                        tool_content += content_item.text
-                                    elif hasattr(content_item, "data"):
-                                        tool_content += str(content_item.data)
+                            # Execute via MCP client
+                            if mcp_client and tool_name in mcp_client.tool_map:
+                                try:
+                                    tool_func = mcp_client.tool_map[tool_name]
+                                    result = tool_func(**(tool_args if isinstance(tool_args, dict) else {}))
+                                    # Handle MCP CallToolResult
+                                    if hasattr(result, 'content'):
+                                        tool_content = str(result.content[0].text) if result.content else str(result)
                                     else:
-                                        tool_content += str(content_item)
+                                        tool_content = str(result)
+                                except Exception as mcp_e:
+                                    tool_content = f"MCP tool error: {str(mcp_e)}"
                             else:
-                                tool_content = str(mcp_result)
-
-                        tool_results.append({
+                                tool_content = f"Tool '{tool_name}' not found in MCP server or Jinxs"
+                        
+                        messages.append({
                             "role": "tool",
                             "tool_call_id": tool_id,
                             "name": tool_name,
                             "content": tool_content
                         })
+                        
+                        print(f"[MCP] tool_result {tool_name}: {tool_content}")
+                        yield {"type": "tool_result", "name": tool_name, "id": tool_id, "result": tool_content}
 
-                        print(f"[MCP] tool_complete {tool_name}")
-                        yield {"type": "tool_complete", "name": tool_name, "id": tool_id, "result_preview": tool_content[:4000]}
                     except Exception as e:
-                        err_msg = f"Error executing {tool_name}: {e}"
-                        tool_results.append({
-                            "role": "tool",
-                            "tool_call_id": tool_id,
-                            "name": tool_name,
-                            "content": err_msg
-                        })
-                        print(f"[MCP] tool_error {tool_name}: {e}")
-                        yield {"type": "tool_error", "name": tool_name, "id": tool_id, "error": str(e)}
+                        error_msg = f"Tool execution error: {str(e)}"
+                        print(f"[MCP] tool_error {tool_name}: {error_msg}")
+                        yield {"type": "tool_error", "name": tool_name, "id": tool_id, "error": error_msg}
 
                 serialized_tool_calls = []
                 for tc in collected_tool_calls:
@@ -3770,14 +3760,12 @@ def stream():
                     "content": collected_content,
                     "tool_calls": serialized_tool_calls
                 })
-                messages.extend(tool_results)
                 tool_results_for_db = tool_results
 
                 prompt = ""
 
             app.mcp_clients[state_key]["messages"] = messages
             return
-
         stream_response = stream_mcp_sse()
 
     else:
@@ -3814,6 +3802,8 @@ def stream():
 
     def event_stream(current_stream_id):
         complete_response = []
+        complete_reasoning = []  # Accumulate reasoning content
+        accumulated_tool_calls = []  # Accumulate all tool calls
         dot_count = 0
         interrupted = False
         tool_call_data = {"id": None, "function_name": None, "arguments": ""}
@@ -3839,17 +3829,30 @@ def stream():
                                 content_piece = delta.get("content")
                                 if content_piece:
                                     complete_response.append(content_piece)
+                                # Accumulate reasoning content from generator chunks
+                                reasoning_piece = delta.get("reasoning_content")
+                                if reasoning_piece:
+                                    complete_reasoning.append(reasoning_piece)
+                        # Accumulate tool calls from generator chunks
+                        if chunk.get("type") == "tool_call":
+                            tc = chunk.get("tool_call", {})
+                            if tc.get("id") and tc.get("name"):
+                                accumulated_tool_calls.append({
+                                    "id": tc.get("id"),
+                                    "function_name": tc.get("name"),
+                                    "arguments": tc.get("arguments", "")
+                                })
+                        if chunk.get("type") == "tool_result":
+                            tool_results_for_db.append({
+                                "name": chunk.get("name"),
+                                "tool_call_id": chunk.get("id"),
+                                "content": chunk.get("result", "")
+                            })
                         continue
                     yield f"data: {json.dumps({'choices':[{'delta':{'content': str(chunk), 'role': 'assistant'},'finish_reason':None}]})}\n\n"
-                # ensure stream termination and cleanup for generator flows
-                yield "data: [DONE]\n\n"
-                with cancellation_lock:
-                    if current_stream_id in cancellation_flags:
-                        del cancellation_flags[current_stream_id]
-                        print(f"Cleaned up cancellation flag for stream ID: {current_stream_id}")
-                return
+                # Generator finished - skip the other stream handling paths
 
-            if isinstance(stream_response, str) :
+            elif isinstance(stream_response, str) :
                 print('stream a str and not a gen')
                 chunk_data = {
                         "id": None,
@@ -3869,7 +3872,7 @@ def stream():
                         ]
                     }
                 yield f"data: {json.dumps(chunk_data)}\n\n"
-                return
+
             elif isinstance(stream_response, dict) and 'output' in stream_response and isinstance(stream_response.get('output'), str):
                 print('stream a str and not a gen')
                 chunk_data = {
@@ -3890,78 +3893,97 @@ def stream():
                         ]
                     }
                 yield f"data: {json.dumps(chunk_data)}\n\n"
-                return
-            for response_chunk in stream_response.get('response', stream_response.get('output')):
-                with cancellation_lock:
-                    if cancellation_flags.get(current_stream_id, False):
-                        print(f"Cancellation flag triggered for {current_stream_id}. Breaking loop.")
-                        interrupted = True
-                        break
 
-                print('.', end="", flush=True)
-                dot_count += 1
-                if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
-                    # Ollama returns ChatResponse objects - support both attribute and dict access
-                    msg = getattr(response_chunk, "message", None) or response_chunk.get("message", {}) if hasattr(response_chunk, "get") else {}
-                    chunk_content = getattr(msg, "content", None) or (msg.get("content") if hasattr(msg, "get") else "") or ""
-                    # Extract Ollama thinking/reasoning tokens
-                    thinking_content = getattr(msg, "thinking", None) or (msg.get("thinking") if hasattr(msg, "get") else None)
-                    # Handle tool calls with robust attribute/dict access
-                    tool_calls = getattr(msg, "tool_calls", None) or (msg.get("tool_calls") if hasattr(msg, "get") else None)
-                    if tool_calls:
-                        for tool_call in tool_calls:
-                            tc_id = getattr(tool_call, "id", None) or (tool_call.get("id") if hasattr(tool_call, "get") else None)
-                            if tc_id:
-                                tool_call_data["id"] = tc_id
-                            tc_func = getattr(tool_call, "function", None) or (tool_call.get("function") if hasattr(tool_call, "get") else None)
-                            if tc_func:
-                                tc_name = getattr(tc_func, "name", None) or (tc_func.get("name") if hasattr(tc_func, "get") else None)
-                                if tc_name:
-                                    tool_call_data["function_name"] = tc_name
-                                tc_args = getattr(tc_func, "arguments", None) or (tc_func.get("arguments") if hasattr(tc_func, "get") else None)
-                                if tc_args:
-                                    arg_val = tc_args
-                                    if isinstance(arg_val, dict):
-                                        arg_val = json.dumps(arg_val)
-                                    tool_call_data["arguments"] += arg_val
-                    if chunk_content:
-                        complete_response.append(chunk_content)
-                    # Extract other fields with robust access
-                    created_at = getattr(response_chunk, "created_at", None) or (response_chunk.get("created_at") if hasattr(response_chunk, "get") else None)
-                    model_name = getattr(response_chunk, "model", None) or (response_chunk.get("model") if hasattr(response_chunk, "get") else model)
-                    msg_role = getattr(msg, "role", None) or (msg.get("role") if hasattr(msg, "get") else "assistant")
-                    done_reason = getattr(response_chunk, "done_reason", None) or (response_chunk.get("done_reason") if hasattr(response_chunk, "get") else None)
-                    chunk_data = {
-                        "id": None, "object": None,
-                        "created": created_at or datetime.datetime.now(),
-                        "model": model_name,
-                        "choices": [{"index": 0, "delta": {"content": chunk_content, "role": msg_role, "reasoning_content": thinking_content}, "finish_reason": done_reason}]
-                    }
-                    yield f"data: {json.dumps(chunk_data)}\n\n"
-                else:
-                    chunk_content = ""
-                    reasoning_content = ""
-                    for choice in response_chunk.choices:
-                        if hasattr(choice.delta, "tool_calls") and choice.delta.tool_calls:
-                            for tool_call in choice.delta.tool_calls:
-                                if tool_call.id:
-                                    tool_call_data["id"] = tool_call.id
-                                if tool_call.function:
-                                    if hasattr(tool_call.function, "name") and tool_call.function.name:
-                                        tool_call_data["function_name"] = tool_call.function.name
-                                    if hasattr(tool_call.function, "arguments") and tool_call.function.arguments:
-                                        tool_call_data["arguments"] += tool_call.function.arguments
-                    for choice in response_chunk.choices:
-                        if hasattr(choice.delta, "reasoning_content"):
-                            reasoning_content += choice.delta.reasoning_content
-                    chunk_content = "".join(choice.delta.content for choice in response_chunk.choices if choice.delta.content is not None)
-                    if chunk_content:
-                        complete_response.append(chunk_content)
-                    chunk_data = {
-                        "id": response_chunk.id, "object": response_chunk.object, "created": response_chunk.created, "model": response_chunk.model,
-                        "choices": [{"index": choice.index, "delta": {"content": choice.delta.content, "role": choice.delta.role, "reasoning_content": reasoning_content if hasattr(choice.delta, "reasoning_content") else None}, "finish_reason": choice.finish_reason} for choice in response_chunk.choices]
-                    }
-                    yield f"data: {json.dumps(chunk_data)}\n\n"
+            elif isinstance(stream_response, dict):
+                for response_chunk in stream_response.get('response', stream_response.get('output')):
+                    with cancellation_lock:
+                        if cancellation_flags.get(current_stream_id, False):
+                            print(f"Cancellation flag triggered for {current_stream_id}. Breaking loop.")
+                            interrupted = True
+                            break
+
+                    print('.', end="", flush=True)
+                    dot_count += 1
+                    if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
+                        # Ollama returns ChatResponse objects - support both attribute and dict access
+                        msg = getattr(response_chunk, "message", None) or response_chunk.get("message", {}) if hasattr(response_chunk, "get") else {}
+                        chunk_content = getattr(msg, "content", None) or (msg.get("content") if hasattr(msg, "get") else "") or ""
+                        # Extract Ollama thinking/reasoning tokens
+                        reasoning_content = getattr(msg, "thinking", None) or (msg.get("thinking") if hasattr(msg, "get") else None)
+                        # Handle tool calls with robust attribute/dict access
+                        tool_calls = getattr(msg, "tool_calls", None) or (msg.get("tool_calls") if hasattr(msg, "get") else None)
+                        if tool_calls:
+                            for tool_call in tool_calls:
+                                tc_id = getattr(tool_call, "id", None) or (tool_call.get("id") if hasattr(tool_call, "get") else None)
+                                if tc_id:
+                                    tool_call_data["id"] = tc_id
+                                tc_func = getattr(tool_call, "function", None) or (tool_call.get("function") if hasattr(tool_call, "get") else None)
+                                if tc_func:
+                                    tc_name = getattr(tc_func, "name", None) or (tc_func.get("name") if hasattr(tc_func, "get") else None)
+                                    if tc_name:
+                                        tool_call_data["function_name"] = tc_name
+                                    tc_args = getattr(tc_func, "arguments", None) or (tc_func.get("arguments") if hasattr(tc_func, "get") else None)
+                                    if tc_args:
+                                        arg_val = tc_args
+                                        if isinstance(arg_val, dict):
+                                            arg_val = json.dumps(arg_val)
+                                        tool_call_data["arguments"] += arg_val
+                                # Accumulate complete tool call info for DB storage (Ollama path)
+                                if tc_id and tc_func and tc_name:
+                                    accumulated_tool_calls.append({
+                                        "id": tc_id,
+                                        "function_name": tc_name,
+                                        "arguments": arg_val if tc_args else ""
+                                    })
+                        # Accumulate reasoning content
+                        if reasoning_content:
+                            complete_reasoning.append(reasoning_content)
+                        if chunk_content:
+                            complete_response.append(chunk_content)
+                        # Extract other fields with robust access
+                        created_at = getattr(response_chunk, "created_at", None) or (response_chunk.get("created_at") if hasattr(response_chunk, "get") else None)
+                        model_name = getattr(response_chunk, "model", None) or (response_chunk.get("model") if hasattr(response_chunk, "get") else model)
+                        msg_role = getattr(msg, "role", None) or (msg.get("role") if hasattr(msg, "get") else "assistant")
+                        done_reason = getattr(response_chunk, "done_reason", None) or (response_chunk.get("done_reason") if hasattr(response_chunk, "get") else None)
+                        chunk_data = {
+                            "id": None, "object": None,
+                            "created": created_at or datetime.datetime.now(),
+                            "model": model_name,
+                            "choices": [{"index": 0, "delta": {"content": chunk_content, "role": msg_role, "reasoning_content": reasoning_content}, "finish_reason": done_reason}]
+                        }
+                        yield f"data: {json.dumps(chunk_data)}\n\n"
+                    else:
+                        chunk_content = ""
+                        reasoning_content = ""
+                        for choice in response_chunk.choices:
+                            if hasattr(choice.delta, "tool_calls") and choice.delta.tool_calls:
+                                for tool_call in choice.delta.tool_calls:
+                                    if tool_call.id:
+                                        tool_call_data["id"] = tool_call.id
+                                    if tool_call.function:
+                                        if hasattr(tool_call.function, "name") and tool_call.function.name:
+                                            tool_call_data["function_name"] = tool_call.function.name
+                                        if hasattr(tool_call.function, "arguments") and tool_call.function.arguments:
+                                            tool_call_data["arguments"] += tool_call.function.arguments
+                                    # Accumulate complete tool call info for DB storage
+                                    if tool_call.id and tool_call.function and tool_call.function.name:
+                                        accumulated_tool_calls.append({
+                                            "id": tool_call.id,
+                                            "function_name": tool_call.function.name,
+                                            "arguments": tool_call.function.arguments or ""
+                                        })
+                        for choice in response_chunk.choices:
+                            if hasattr(choice.delta, "reasoning_content") and choice.delta.reasoning_content:
+                                reasoning_content += choice.delta.reasoning_content
+                                complete_reasoning.append(choice.delta.reasoning_content)
+                        chunk_content = "".join(choice.delta.content for choice in response_chunk.choices if choice.delta.content is not None)
+                        if chunk_content:
+                            complete_response.append(chunk_content)
+                        chunk_data = {
+                            "id": response_chunk.id, "object": response_chunk.object, "created": response_chunk.created, "model": response_chunk.model,
+                            "choices": [{"index": choice.index, "delta": {"content": choice.delta.content, "role": choice.delta.role, "reasoning_content": reasoning_content if hasattr(choice.delta, "reasoning_content") else None}, "finish_reason": choice.finish_reason} for choice in response_chunk.choices]
+                        }
+                        yield f"data: {json.dumps(chunk_data)}\n\n"
 
         except Exception as e:
             print(f"\nAn exception occurred during streaming for {current_stream_id}: {e}")
@@ -4007,7 +4029,7 @@ def stream():
                         message_id=generate_message_id(),
                     )
 
-            # Save assistant message to the database
+            # Save assistant message to the database with reasoning content and tool calls
             npc_name_to_save = npc_object.name if npc_object else ''
             save_conversation_message(
                 command_history,
@@ -4020,6 +4042,9 @@ def stream():
                 npc=npc_name_to_save,
                 team=team,
                 message_id=message_id,
+                reasoning_content=''.join(complete_reasoning) if complete_reasoning else None,
+                tool_calls=accumulated_tool_calls if accumulated_tool_calls else None,
+                tool_results=tool_results_for_db if tool_results_for_db else None,
             )
 
             # Start background tasks for memory extraction and context compression
@@ -4181,11 +4206,24 @@ def get_conversation_messages(conversation_id):
     try:
         engine = get_db_connection()
         with engine.connect() as conn:
-            
+
             query = text("""
                 WITH ranked_messages AS (
                     SELECT
-                        ch.*,
+                        ch.id,
+                        ch.message_id,
+                        ch.timestamp,
+                        ch.role,
+                        ch.content,
+                        ch.conversation_id,
+                        ch.directory_path,
+                        ch.model,
+                        ch.provider,
+                        ch.npc,
+                        ch.team,
+                        ch.reasoning_content,
+                        ch.tool_calls,
+                        ch.tool_results,
                         GROUP_CONCAT(ma.id) as attachment_ids,
                         ROW_NUMBER() OVER (
                             PARTITION BY ch.role, strftime('%s', ch.timestamp)
@@ -4206,20 +4244,32 @@ def get_conversation_messages(conversation_id):
             result = conn.execute(query, {"conversation_id": conversation_id})
             messages = result.fetchall()
 
+            def parse_json_field(value):
+                """Parse a JSON string field, returning None if empty or invalid."""
+                if not value:
+                    return None
+                try:
+                    return json.loads(value)
+                except (json.JSONDecodeError, TypeError):
+                    return None
+
             return jsonify(
                 {
                     "messages": [
                         {
-                            "message_id": msg[1] if len(msg) > 1 else None,  
+                            "message_id": msg[1] if len(msg) > 1 else None,
                             "role": msg[3] if len(msg) > 3 else None,
                             "content": msg[4] if len(msg) > 4 else None,
-                            "timestamp": msg[5] if len(msg) > 5 else None,
-                            "model": msg[6] if len(msg) > 6 else None,
-                            "provider": msg[7] if len(msg) > 7 else None,
-                            "npc": msg[8] if len(msg) > 8 else None,
+                            "timestamp": msg[2] if len(msg) > 2 else None,
+                            "model": msg[7] if len(msg) > 7 else None,
+                            "provider": msg[8] if len(msg) > 8 else None,
+                            "npc": msg[9] if len(msg) > 9 else None,
+                            "reasoningContent": msg[11] if len(msg) > 11 else None,
+                            "toolCalls": parse_json_field(msg[12]) if len(msg) > 12 else None,
+                            "toolResults": parse_json_field(msg[13]) if len(msg) > 13 else None,
                             "attachments": (
                                 get_message_attachments(msg[1])
-                                if len(msg) > 1 and msg[-1]  
+                                if len(msg) > 1 and msg[14]  # attachment_ids is at index 14
                                 else []
                             ),
                         }
@@ -4263,31 +4313,19 @@ def ollama_status():
 @app.route("/api/ollama/tool_models", methods=["GET"])
 def get_ollama_tool_models():
     """
-    Best-effort detection of Ollama models whose templates include tool-call support.
-    We scan templates for tool placeholders; if none are found we assume tools are unsupported.
+    Returns all Ollama models. Tool capability detection is unreliable,
+    so we don't filter - let the user try and the backend will handle failures.
     """
     try:
         detected = []
         listing = ollama.list()
         for model in listing.get("models", []):
             name = getattr(model, "model", None) or model.get("name") if isinstance(model, dict) else None
-            if not name:
-                continue
-            try:
-                details = ollama.show(name)
-                tmpl = details.get("template") or ""
-                if "{{- if .Tools" in tmpl or "{{- range .Tools" in tmpl or "{{- if .ToolCalls" in tmpl:
-                    detected.append(name)
-                    continue
-                metadata = details.get("metadata") or {}
-                if metadata.get("tools") or metadata.get("tool_calls"):
-                    detected.append(name)
-            except Exception as inner_e:
-                print(f"Warning: could not inspect ollama model {name} for tool support: {inner_e}")
-                continue
+            if name:
+                detected.append(name)
         return jsonify({"models": detected, "error": None})
     except Exception as e:
-        print(f"Error listing Ollama tool-capable models: {e}")
+        print(f"Error listing Ollama models: {e}")
         return jsonify({"models": [], "error": str(e)}), 500
 
 

{npcpy-1.3.2.dist-info → npcpy-1.3.4.dist-info}/METADATA

@@ -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.dist-info → npcpy-1.3.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
 npcpy/__init__.py,sha256=uJcJGjR1mWvE69GySNAufkgiRwJA28zdObDBWaxp0tY,505
-npcpy/llm_funcs.py,sha256=KJpjN6q5iW_qdUfgt4tzYENCAu86376io8eFZ7wp76Y,78081
+npcpy/llm_funcs.py,sha256=sc-sXA48VpJFy7vWyh8M5ZY2HQ362le_BfAtDA3Gh7Y,76489
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
 npcpy/ml_funcs.py,sha256=UI7k7JR4XOH_VXR-xxLaO4r9Kyx_jBaEnp3TUIY7ZLQ,22657
 npcpy/npc_array.py,sha256=fVTxcMiXV-lvltmuwaRnTU9D3ikPq3-7k5wzp7MA5OY,40224
 npcpy/npc_compiler.py,sha256=X2BjMqKL7hbS37PPkSDGgZSF_PF_GNVGLd92ePRNRwQ,111868
 npcpy/npc_sysenv.py,sha256=rtE3KrXvIuOEpMq1CW5eK5K0o3f6mXagNXCeMnhHob4,36736
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=Nxigo7NR189RFDhdh3whVeWEyjTaopCzXfk6HsTJP4A,176384
+npcpy/serve.py,sha256=5S3v4lp3fPozsnp_48SuVenf3JTiSiIBRxgfAReovmM,181539
 npcpy/tools.py,sha256=A5_oVmZkzGnI3BI-NmneuxeXQq-r29PbpAZP4nV4jrc,5303
 npcpy/data/__init__.py,sha256=1tcoChR-Hjn905JDLqaW9ElRmcISCTJdE7BGXPlym2Q,642
 npcpy/data/audio.py,sha256=3qryGXnWHa4JFMonjuX-lf0fCrF8jmbHe7mHAuOdua0,12397
@@ -17,7 +17,7 @@ npcpy/data/text.py,sha256=jP0a1qZZaSJdK-LdZTn2Jjdxqmkd3efxDLEoxflJQeY,5010
 npcpy/data/video.py,sha256=H-V3mTu_ktD9u-QhYeo4aW3u9z0AtoAdRZmvRPEpE98,2887
 npcpy/data/web.py,sha256=ARGoVKUlQmaiX0zJbSvvFmRCwOv_Z7Pcan9c5GxYObQ,5117
 npcpy/ft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcpy/ft/diff.py,sha256=OjdrVn_rFkFcP3MnzVgIhCdtfnbtnxQcvl5XCc6Wi-o,12376
+npcpy/ft/diff.py,sha256=2-NbY0p0CP5Qr9mnnncxRBwzmxRq9NKcl8B5BeT1vQ4,12319
 npcpy/ft/ge.py,sha256=0VzIiXq2wCzGcK1x0Wd-myJ3xRf-FNaPg0GkHEZegUM,3552
 npcpy/ft/memory_trainer.py,sha256=QZPznxEEwXbOGroHdMUMa5xpqlNwgV6nqOazI2xgrnQ,6635
 npcpy/ft/model_ensembler.py,sha256=BRX4hJ_rvF1vKTzjMhlahZqPttUgc3PqmzUJDqIfIps,10038
@@ -29,10 +29,10 @@ npcpy/gen/audio_gen.py,sha256=w4toESu7nmli1T5FOwRRCGC_QK9W-SMWknYYkbRv9jE,635
 npcpy/gen/embeddings.py,sha256=QStTJ2ELiC379OEZsLEgGGIIFD267Y8zQchs7HRn2Zg,2089
 npcpy/gen/image_gen.py,sha256=VflU_wJsKWJarOVwZtL2M8ymDFfKNz8WX66Rwk4obeo,21778
 npcpy/gen/ocr.py,sha256=rgmXWHrCYX1Po-qG_LrNFbVYEZ8aaupxFTgparcoB_Y,6554
-npcpy/gen/response.py,sha256=8oZRRmoh85RyR6sgGsk-H6cpXcCjkBsn-8Wix0mW3bE,40101
+npcpy/gen/response.py,sha256=lH3fR3Sx1Cm8Zc0MJyHzTuuwTjVPgSJUZVxnkFIhzLE,40643
 npcpy/gen/video_gen.py,sha256=RFi3Zcq_Hn3HIcfoF3mijQ6G7RYFZaM_9pjPTh-8E64,3239
 npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcpy/memory/command_history.py,sha256=vWzZ4F4o0XOSHn50SkdP885jG1aZIZvfcPAh8EZWlQk,54497
+npcpy/memory/command_history.py,sha256=1488weOYtnm-wyenUvZKHaNgZe5OKOZSaQ35WNeceiM,56226
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
 npcpy/memory/knowledge_graph.py,sha256=2XpIlsyPdAOnzQ6kkwP6MWPGwL3P6V33_3suNJYMMJE,48681
 npcpy/memory/memory_processor.py,sha256=6PfVnSBA9ag5EhHJinXoODfEPTlDDoaT0PtCCuZO6HI,2598
@@ -50,8 +50,8 @@ npcpy/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/work/desktop.py,sha256=F3I8mUtJp6LAkXodsh8hGZIncoads6c_2Utty-0EdDA,2986
 npcpy/work/plan.py,sha256=QyUwg8vElWiHuoS-xK4jXTxxHvkMD3VkaCEsCmrEPQk,8300
 npcpy/work/trigger.py,sha256=P1Y8u1wQRsS2WACims_2IdkBEar-iBQix-2TDWoW0OM,9948
-npcpy-1.3.2.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.3.2.dist-info/METADATA,sha256=KmIJEKnatu027fuhR2XJQs7kNlrqaVgzTqG4eKQECCc,37884
-npcpy-1.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.3.2.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.3.2.dist-info/RECORD,,
+npcpy-1.3.4.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.3.4.dist-info/METADATA,sha256=-dPHdZlVOsr_QtmxxbLl7W4cSkXH8Ccaf-w-qRB0yAY,37884
+npcpy-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.3.4.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.3.4.dist-info/RECORD,,