npcpy 1.2.23__tar.gz → 1.2.25__tar.gz

{npcpy-1.2.23/npcpy.egg-info → npcpy-1.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.23
+Version: 1.2.25
 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.2.23 → npcpy-1.2.25}/npcpy/npc_compiler.py

@@ -563,12 +563,10 @@ def get_npc_action_space(npc=None, team=None):
         }
     
     return actions
-
-
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     inputs = {}
 
-    
+    # Create flag mapping for inputs
     flag_mapping = {}
     for input_ in jinx.inputs:
         if isinstance(input_, str):
@@ -579,46 +577,63 @@ def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
             flag_mapping[f"-{key[0]}"] = key
             flag_mapping[f"--{key}"] = key
 
-    
+    # Parse key=value pairs first
     used_args = set()
     for i, arg in enumerate(args):
-        if arg in flag_mapping:
+        if '=' in arg and not arg.startswith('-'):
+            key, value = arg.split('=', 1)
+            key = key.strip().strip("'\"")
+            value = value.strip().strip("'\"")
+            inputs[key] = value
+            used_args.add(i)
+
+    # Parse flags
+    for i, arg in enumerate(args):
+        if i in used_args:
+            continue
             
-            if i + 1 < len(args):
+        if arg in flag_mapping:
+            if i + 1 < len(args) and not args[i + 1].startswith('-'):
                 input_name = flag_mapping[arg]
                 inputs[input_name] = args[i + 1]
                 used_args.add(i)
                 used_args.add(i + 1)
             else:
-                print(f"Warning: {arg} flag is missing a value.")
+                # Boolean flag
+                input_name = flag_mapping[arg]
+                inputs[input_name] = True
+                used_args.add(i)
 
-    
+    # Handle remaining positional arguments
     unused_args = [arg for i, arg in enumerate(args) if i not in used_args]
-    if unused_args and jinx.inputs:
-        first_input = jinx.inputs[0]
-        if isinstance(first_input, str):
-            inputs[first_input] = " ".join(unused_args)
-        elif isinstance(first_input, dict):
-            key = list(first_input.keys())[0]
-            inputs[key] = " ".join(unused_args)
-
     
+    # Map positional args to jinx inputs in order
+    jinx_input_names = []
+    for input_ in jinx.inputs:
+        if isinstance(input_, str):
+            jinx_input_names.append(input_)
+        elif isinstance(input_, dict):
+            jinx_input_names.append(list(input_.keys())[0])
+    
+    for i, arg in enumerate(unused_args):
+        if i < len(jinx_input_names):
+            input_name = jinx_input_names[i]
+            if input_name not in inputs:  # Don't overwrite existing values
+                inputs[input_name] = arg
+
+    # Set default values for missing inputs
     for input_ in jinx.inputs:
         if isinstance(input_, str):
             if input_ not in inputs:
-                if any(args):  
-                    raise ValueError(f"Missing required input: {input_}")
-                else:
-                    inputs[input_] = None  
+                raise ValueError(f"Missing required input: {input_}")
         elif isinstance(input_, dict):
             key = list(input_.keys())[0]
+            default_value = input_[key]
             if key not in inputs:
-                inputs[key] = input_[key]
+                inputs[key] = default_value
 
     return inputs
 
-
-
 from npcpy.memory.command_history import load_kg_from_db, save_kg_to_db
 from npcpy.memory.knowledge_graph import kg_initial, kg_evolve_incremental, kg_sleep_process, kg_dream_process
 from npcpy.llm_funcs import get_llm_response, breathe

{npcpy-1.2.23 → npcpy-1.2.25}/npcpy/npc_sysenv.py

@@ -63,7 +63,7 @@ warnings.filterwarnings("ignore", module="torch.serialization")
 os.environ["PYTHONWARNINGS"] = "ignore"
 os.environ["SDL_AUDIODRIVER"] = "dummy"
 
-def check_internet_connection(timeout=0.5):
+def check_internet_connection(timeout=5):
     """
     Checks for internet connectivity by trying to connect to a well-known host.
     """
@@ -87,16 +87,78 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                         key, value = line.split("=", 1)
                         env_vars[key.strip()] = value.strip().strip("\"'")
 
-    
     internet_available = check_internet_connection()
     if not internet_available:
-        logging.info("No internet connection detected. External API calls will be skipped (effective airplane_mode).")
-        
+        logging.info(
+            "No internet connection detected. "
+            "External API calls will be skipped."
+        )
         airplane_mode = True
     else:
-        logging.info("Internet connection detected. Proceeding based on 'airplane_mode' parameter.")
+        logging.info(
+            "Internet connection detected. "
+            "Proceeding based on 'airplane_mode' parameter."
+        )
+    
+    custom_providers = load_custom_providers()
+    
+    for provider_name, config in custom_providers.items():
+        api_key_var = config.get('api_key_var')
+        if not api_key_var:
+            api_key_var = f"{provider_name.upper()}_API_KEY"
+        
+        if api_key_var in env_vars or os.environ.get(api_key_var):
+            try:
+                import requests
+                
+                def fetch_custom_models():
+                    base_url = config.get('base_url', '')
+                    headers = config.get('headers', {})
+                    
+                    api_key = env_vars.get(api_key_var) or \
+                              os.environ.get(api_key_var)
+                    if api_key:
+                        headers['Authorization'] = f'Bearer {api_key}'
+                    
+                    models_endpoint = f"{base_url.rstrip('/')}/models"
+                    response = requests.get(
+                        models_endpoint, 
+                        headers=headers,
+                        timeout=3.5
+                    )
+                    
+                    if response.status_code == 200:
+                        data = response.json()
+                        
+                        if isinstance(data, dict) and 'data' in data:
+                            return [
+                                m['id'] for m in data['data'] 
+                                if 'id' in m
+                            ]
+                        elif isinstance(data, list):
+                            return [
+                                m['id'] for m in data 
+                                if isinstance(m, dict) and 'id' in m
+                            ]
+                    return []
+                
+                models = fetch_custom_models()
+                for model in models:
+                    available_models[model] = provider_name
+                    
+                logging.info(
+                    f"Loaded {len(models)} models "
+                    f"from custom provider '{provider_name}'"
+                )
+                
+            except Exception as e:
+                logging.warning(
+                    f"Failed to load models from "
+                    f"custom provider '{provider_name}': {e}"
+                )
     
 
+    airplane_mode = False
     if not airplane_mode:
         timeout_seconds = 3.5
         
@@ -802,50 +864,116 @@ def load_env_from_execution_dir() -> None:
 
 
 
+
 def lookup_provider(model: str) -> str:
     """
-    Function Description:
-        This function determines the provider based on the model name.
+    Determine the provider based on the model name.
+    Checks custom providers first, then falls back to known providers.
+    
     Args:
-        model (str): The model name.
-    Keyword Args:
-        None
+        model: The model name
+        
     Returns:
-        str: The provider based on the model name.
+        The provider name or None if not found
     """
+    custom_providers = load_custom_providers()
+    
+    for provider_name, config in custom_providers.items():
+        if model.startswith(f"{provider_name}-"):
+            return provider_name
+        
+        try:
+            import requests
+            api_key_var = config.get('api_key_var') or \
+                         f"{provider_name.upper()}_API_KEY"
+            api_key = os.environ.get(api_key_var)
+            
+            if api_key:
+                base_url = config.get('base_url', '')
+                headers = config.get('headers', {})
+                headers['Authorization'] = f'Bearer {api_key}'
+                
+                models_endpoint = f"{base_url.rstrip('/')}/models"
+                response = requests.get(
+                    models_endpoint, 
+                    headers=headers, 
+                    timeout=1.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    models = []
+                    
+                    if isinstance(data, dict) and 'data' in data:
+                        models = [m['id'] for m in data['data']]
+                    elif isinstance(data, list):
+                        models = [m['id'] for m in data]
+                    
+                    if model in models:
+                        return provider_name
+        except:
+            pass
+    
     if model == "deepseek-chat" or model == "deepseek-reasoner":
         return "deepseek"
+        
     ollama_prefixes = [
-        "llama",
-        "deepseek",
-        "qwen",
-        "llava",
-        "phi",
-        "mistral",
-        "mixtral",
-        "dolphin",
-        "codellama",
-        "gemma",
-    ]
+        "llama", "deepseek", "qwen", "llava", 
+        "phi", "mistral", "mixtral", "dolphin", 
+        "codellama", "gemma",]
     if any(model.startswith(prefix) for prefix in ollama_prefixes):
         return "ollama"
 
-    
     openai_prefixes = ["gpt-", "dall-e-", "whisper-", "o1"]
     if any(model.startswith(prefix) for prefix in openai_prefixes):
         return "openai"
 
-    
     if model.startswith("claude"):
         return "anthropic"
     if model.startswith("gemini"):
         return "gemini"
     if "diffusion" in model:
         return "diffusers"
+        
     return None
+
+
+def load_custom_providers():
+    """
+    Load custom provider configurations from .npcshrc
+    
+    Returns:
+        dict: Custom provider configurations keyed by provider name
+    """
+    custom_providers = {}
+    npcshrc_path = os.path.expanduser("~/.npcshrc")
+    
+    if os.path.exists(npcshrc_path):
+        with open(npcshrc_path, "r") as f:
+            for line in f:
+                line = line.split("#")[0].strip()
+                if "CUSTOM_PROVIDER_" in line and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip().replace("export ", "")
+                    value = value.strip().strip("\"'")
+                    
+                    try:
+                        config = json.loads(value)
+                        provider_name = key.replace(
+                            "CUSTOM_PROVIDER_", ""
+                        ).lower()
+                        custom_providers[provider_name] = config
+                    except json.JSONDecodeError as e:
+                        logging.warning(
+                            f"Failed to parse custom provider {key}: {e}"
+                        )
+                        continue
+    
+    return custom_providers
 load_env_from_execution_dir()
 deepseek_api_key = os.getenv("DEEPSEEK_API_KEY", None)
 gemini_api_key = os.getenv("GEMINI_API_KEY", None)
 
 anthropic_api_key = os.getenv("ANTHROPIC_API_KEY", None)
 openai_api_key = os.getenv("OPENAI_API_KEY", None)
+

{npcpy-1.2.23 → npcpy-1.2.25}/npcpy/serve.py

@@ -504,7 +504,233 @@ def get_global_settings():
         return jsonify({"error": str(e)}), 500
 
 
+@app.route("/api/jinxs/available", methods=["GET"])
+def get_available_jinxs():
+    """
+    Get all available jinxs for a given NPC and/or team.
+    Returns a list of jinx names that can be executed.
+    """
+    try:
+        current_path = request.args.get('currentPath')
+        npc_name = request.args.get('npc')
+        
+        jinx_names = set()  # Use set to avoid duplicates
+        
+        # Get team jinxs from project directory
+        if current_path:
+            team_jinxs_dir = os.path.join(current_path, 'npc_team', 'jinxs')
+            if os.path.exists(team_jinxs_dir):
+                for file in os.listdir(team_jinxs_dir):
+                    if file.endswith('.jinx'):
+                        jinx_names.add(file[:-5])  # Remove .jinx extension
+        
+        # Get global jinxs
+        global_jinxs_dir = os.path.expanduser('~/.npcsh/npc_team/jinxs')
+        if os.path.exists(global_jinxs_dir):
+            for file in os.listdir(global_jinxs_dir):
+                if file.endswith('.jinx'):
+                    jinx_names.add(file[:-5])
+        
+        # Get NPC-specific jinxs if NPC is specified
+        if npc_name:
+            # Try to load the NPC and get its jinxs
+            db_conn = get_db_connection()
+            npc_object = load_npc_by_name_and_source(npc_name, 'project', db_conn, current_path)
+            if not npc_object:
+                npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
+            
+            if npc_object and hasattr(npc_object, 'jinxs_dict') and npc_object.jinxs_dict:
+                jinx_names.update(npc_object.jinxs_dict.keys())
+        
+        return jsonify({
+            'jinxs': sorted(list(jinx_names)),
+            'error': None
+        })
+        
+    except Exception as e:
+        print(f"Error getting available jinxs: {str(e)}")
+        traceback.print_exc()
+        return jsonify({'jinxs': [], 'error': str(e)}), 500
+
 
+@app.route("/api/jinx/execute", methods=["POST"])
+def execute_jinx():
+    """
+    Execute a specific jinx with provided arguments.
+    Streams the output back to the client.
+    """
+    data = request.json
+    
+    stream_id = data.get("streamId")
+    if not stream_id:
+        stream_id = str(uuid.uuid4())
+    
+    with cancellation_lock:
+        cancellation_flags[stream_id] = False
+    
+    jinx_name = data.get("jinxName")
+    jinx_args = data.get("jinxArgs", [])
+    conversation_id = data.get("conversationId")
+    model = data.get("model")
+    provider = data.get("provider")
+    npc_name = data.get("npc")
+    npc_source = data.get("npcSource", "global")
+    current_path = data.get("currentPath")
+    
+    if not jinx_name:
+        return jsonify({"error": "jinxName is required"}), 400
+    
+    # Load project environment if applicable
+    if current_path:
+        load_project_env(current_path)
+    
+    # Load the NPC
+    npc_object = None
+    if npc_name:
+        db_conn = get_db_connection()
+        npc_object = load_npc_by_name_and_source(npc_name, npc_source, db_conn, current_path)
+        if not npc_object and npc_source == 'project':
+            npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
+    
+    # Try to find the jinx
+    jinx = None
+    
+    # Check NPC's jinxs
+    if npc_object and hasattr(npc_object, 'jinxs_dict') and jinx_name in npc_object.jinxs_dict:
+        jinx = npc_object.jinxs_dict[jinx_name]
+    
+    # Check team jinxs
+    if not jinx and current_path:
+        team_jinx_path = os.path.join(current_path, 'npc_team', 'jinxs', f'{jinx_name}.jinx')
+        if os.path.exists(team_jinx_path):
+            jinx = Jinx(jinx_path=team_jinx_path)
+    
+    # Check global jinxs
+    if not jinx:
+        global_jinx_path = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/{jinx_name}.jinx')
+        if os.path.exists(global_jinx_path):
+            jinx = Jinx(jinx_path=global_jinx_path)
+    
+    if not jinx:
+        return jsonify({"error": f"Jinx '{jinx_name}' not found"}), 404
+    
+    # Extract inputs from args
+    from npcpy.npc_compiler import extract_jinx_inputs
+    input_values = extract_jinx_inputs(jinx_args, jinx)
+    
+    # Get conversation history
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    messages = fetch_messages_for_conversation(conversation_id)
+    
+    # Prepare jinxs_dict for execution
+    all_jinxs = {}
+    if npc_object and hasattr(npc_object, 'jinxs_dict'):
+        all_jinxs.update(npc_object.jinxs_dict)
+    
+    def event_stream(current_stream_id):
+        try:
+            # Execute the jinx
+            result = jinx.execute(
+                input_values=input_values,
+                jinxs_dict=all_jinxs,
+                jinja_env=npc_object.jinja_env if npc_object else None,
+                npc=npc_object,
+                messages=messages
+            )
+            
+            # Get output
+            output = result.get('output', str(result))
+            messages_updated = result.get('messages', messages)
+            
+            # Check for interruption
+            with cancellation_lock:
+                if cancellation_flags.get(current_stream_id, False):
+                    yield f"data: {json.dumps({'type': 'interrupted'})}\n\n"
+                    return
+            
+            # Stream the output in chunks for consistent UI experience
+            if isinstance(output, str):
+                chunk_size = 50  # Characters per chunk
+                for i in range(0, len(output), chunk_size):
+                    chunk = output[i:i + chunk_size]
+                    chunk_data = {
+                        "id": None,
+                        "object": None,
+                        "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "content": chunk,
+                                "role": "assistant"
+                            },
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+            else:
+                # Non-string output, send as single chunk
+                chunk_data = {
+                    "id": None,
+                    "object": None,
+                    "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {
+                            "content": str(output),
+                            "role": "assistant"
+                        },
+                        "finish_reason": None
+                    }]
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+            
+            # Send completion message
+            yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
+            
+            # Save to conversation history
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "user",
+                f"/{jinx_name} {' '.join(jinx_args)}",
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "assistant",
+                str(output),
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+        except Exception as e:
+            print(f"Error executing jinx {jinx_name}: {str(e)}")
+            traceback.print_exc()
+            error_data = {
+                "type": "error",
+                "error": str(e)
+            }
+            yield f"data: {json.dumps(error_data)}\n\n"
+        
+        finally:
+            with cancellation_lock:
+                if current_stream_id in cancellation_flags:
+                    del cancellation_flags[current_stream_id]
+    
+    return Response(event_stream(stream_id), mimetype="text/event-stream")
 
 @app.route("/api/settings/global", methods=["POST", "OPTIONS"])
 def save_global_settings():
@@ -1288,6 +1514,187 @@ def get_available_image_models(current_path=None):
 
     return unique_models
 
+@app.route('/api/generative_fill', methods=['POST'])
+def generative_fill():
+    data = request.get_json()
+    image_path = data.get('imagePath')
+    mask_data = data.get('mask')
+    prompt = data.get('prompt')
+    model = data.get('model')
+    provider = data.get('provider')
+    
+    if not all([image_path, mask_data, prompt, model, provider]):
+        return jsonify({"error": "Missing required fields"}), 400
+    
+    try:
+        image_path = os.path.expanduser(image_path)
+        
+        mask_b64 = mask_data.split(',')[1] if ',' in mask_data else mask_data
+        mask_bytes = base64.b64decode(mask_b64)
+        mask_image = Image.open(BytesIO(mask_bytes))
+        
+        original_image = Image.open(image_path)
+        
+        if provider == 'openai':
+            result = inpaint_openai(original_image, mask_image, prompt, model)
+        elif provider == 'gemini':
+            result = inpaint_gemini(original_image, mask_image, prompt, model)
+        elif provider == 'diffusers':
+            result = inpaint_diffusers(original_image, mask_image, prompt, model)
+        else:
+            return jsonify({"error": f"Provider {provider} not supported"}), 400
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"inpaint_{timestamp}.png"
+        save_dir = os.path.dirname(image_path)
+        result_path = os.path.join(save_dir, filename)
+        
+        result.save(result_path)
+        
+        return jsonify({"resultPath": result_path, "error": None})
+        
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+def inpaint_openai(image, mask, prompt, model):
+    import io
+    from openai import OpenAI
+    from PIL import Image
+    import base64
+    
+    client = OpenAI()
+    
+    original_size = image.size
+    
+    if model == 'dall-e-2':
+        valid_sizes = ['256x256', '512x512', '1024x1024']
+        max_dim = max(image.width, image.height)
+        
+        if max_dim <= 256:
+            target_size = (256, 256)
+            size_str = '256x256'
+        elif max_dim <= 512:
+            target_size = (512, 512)
+            size_str = '512x512'
+        else:
+            target_size = (1024, 1024)
+            size_str = '1024x1024'
+    else:
+        valid_sizes = {
+            (1024, 1024): "1024x1024",
+            (1024, 1536): "1024x1536", 
+            (1536, 1024): "1536x1024"
+        }
+        
+        target_size = (1024, 1024)
+        for size in valid_sizes.keys():
+            if image.width > image.height and size == (1536, 1024):
+                target_size = size
+                break
+            elif image.height > image.width and size == (1024, 1536):
+                target_size = size
+                break
+        
+        size_str = valid_sizes[target_size]
+    
+    resized_image = image.resize(target_size, Image.Resampling.LANCZOS)
+    resized_mask = mask.resize(target_size, Image.Resampling.LANCZOS)
+    
+    img_bytes = io.BytesIO()
+    resized_image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    img_bytes.name = 'image.png'
+    
+    mask_bytes = io.BytesIO()
+    resized_mask.save(mask_bytes, format='PNG')
+    mask_bytes.seek(0)
+    mask_bytes.name = 'mask.png'
+    
+    response = client.images.edit(
+        model=model,
+        image=img_bytes,
+        mask=mask_bytes,
+        prompt=prompt,
+        n=1,
+        size=size_str
+    )
+    
+    if response.data[0].url:
+        import requests
+        img_data = requests.get(response.data[0].url).content
+    elif hasattr(response.data[0], 'b64_json'):
+        img_data = base64.b64decode(response.data[0].b64_json)
+    else:
+        raise Exception("No image data in response")
+    
+    result_image = Image.open(io.BytesIO(img_data))
+    return result_image.resize(original_size, Image.Resampling.LANCZOS)
+
+def inpaint_diffusers(image, mask, prompt, model):
+    from diffusers import StableDiffusionInpaintPipeline
+    import torch
+    
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+        model,
+        torch_dtype=torch.float16
+    )
+    pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    result = pipe(
+        prompt=prompt,
+        image=image,
+        mask_image=mask
+    ).images[0]
+    
+    return result
+def inpaint_gemini(image, mask, prompt, model):
+    from npcpy.gen.image_gen import generate_image
+    import io
+    import numpy as np
+    
+    mask_np = np.array(mask.convert('L'))
+    ys, xs = np.where(mask_np > 128)
+    
+    if len(xs) == 0:
+        return image
+    
+    x_center = int(np.mean(xs))
+    y_center = int(np.mean(ys))
+    width_pct = (xs.max() - xs.min()) / image.width * 100
+    height_pct = (ys.max() - ys.min()) / image.height * 100
+    
+    position = "center"
+    if y_center < image.height / 3:
+        position = "top"
+    elif y_center > 2 * image.height / 3:
+        position = "bottom"
+    
+    if x_center < image.width / 3:
+        position += " left"
+    elif x_center > 2 * image.width / 3:
+        position += " right"
+    
+    img_bytes = io.BytesIO()
+    image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    
+    full_prompt =  f"""Using the provided image, change only the region in the {position} 
+        approximately {int(width_pct)}% wide by {int(height_pct)}% tall) to: {prompt}. 
+        
+        Keep everything else exactly the same, matching the original lighting and style.
+        You are in-painting the image. You should not be changing anything other than what was requested in prompt: {prompt}
+        """    
+    results = generate_image(
+        prompt=full_prompt,
+        model=model,
+        provider='gemini',
+        attachments=[img_bytes],
+        n_images=1
+    )
+    
+    return results[0] if results else None
 
 @app.route('/api/generate_images', methods=['POST'])
 def generate_images():
@@ -1942,7 +2349,7 @@ def stream():
 
                 print('.', end="", flush=True)
                 dot_count += 1
-                if "hf.co" in model or provider == 'ollama':
+                if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
                     chunk_content = response_chunk["message"]["content"] if "message" in response_chunk and "content" in response_chunk["message"] else ""
                     if "message" in response_chunk and "tool_calls" in response_chunk["message"]:
                         for tool_call in response_chunk["message"]["tool_calls"]:
@@ -1959,7 +2366,9 @@ def stream():
                     if chunk_content:
                         complete_response.append(chunk_content)
                     chunk_data = {
-                        "id": None, "object": None, "created": response_chunk["created_at"], "model": response_chunk["model"],
+                        "id": None, "object": None, 
+                        "created": response_chunk["created_at"] or datetime.datetime.now(), 
+                        "model": response_chunk["model"],
                         "choices": [{"index": 0, "delta": {"content": chunk_content, "role": response_chunk["message"]["role"]}, "finish_reason": response_chunk.get("done_reason")}]
                     }
                     yield f"data: {json.dumps(chunk_data)}\n\n"

{npcpy-1.2.23 → npcpy-1.2.25/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.23
+Version: 1.2.25
 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.2.23 → npcpy-1.2.25}/setup.py

@@ -83,7 +83,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.2.23",
+    version="1.2.25",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={