npcpy 1.1.28__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/llm_funcs.py

@@ -15,6 +15,8 @@ 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
 
+from datetime import datetime 
+
 def gen_image(
     prompt: str,
     model: str = None,
@@ -24,6 +26,8 @@ def gen_image(
     width: int = 1024,
     n_images: int=1, 
     input_images: List[Union[str, bytes, PIL.Image.Image]] = None,
+    save = False, 
+    filename = '',
 ):
     """This function generates an image using the specified provider and model.
     Args:
@@ -48,7 +52,7 @@ def gen_image(
         if npc.api_url is not None:
             api_url = npc.api_url
 
-    image = generate_image(
+    images = generate_image(
         prompt=prompt,
         model=model,
         provider=provider,
@@ -58,7 +62,14 @@ def gen_image(
         n_images=n_images, 
         
     )
-    return image
+    if save:
+        if len(filename) == 0 :
+            todays_date = datetime.now().strftime("%Y-%m-%d")
+            filename = 'vixynt_gen'
+        for i, image in enumerate(images):
+            
+            image.save(filename+'_'+str(i)+'.png')
+    return images
 
 
 def gen_video(
@@ -94,6 +105,7 @@ def gen_video(
         try:
             output_path = generate_video_veo3(
                 prompt=prompt,
+                model=model,
                 negative_prompt=negative_prompt,
                 output_path=output_path,
             )
@@ -107,7 +119,7 @@ def gen_video(
             provider = "diffusers"
     
     if provider == "diffusers" or provider is None:
-        # Use diffusers as default/fallback
+      
         output_path = generate_video_diffusers(
             prompt,
             model,
@@ -143,6 +155,7 @@ def get_llm_response(
     context=None,    
     stream: bool = False,
     attachments: List[str] = None,
+    include_usage: bool = False,
     **kwargs,
 ):
     """This function generates a response using the specified provider and model.
@@ -190,7 +203,7 @@ def get_llm_response(
         system_message = get_system_message(npc, team) 
     else: 
         system_message = "You are a helpful assistant."
-    #print(system_message)
+   
 
     if context is not None:
         context_str = f'User Provided Context: {context}'
@@ -208,6 +221,8 @@ def get_llm_response(
     elif prompt:
         messages.append({"role": "user", 
                          "content": prompt + context_str})    
+    #import pdb 
+    #pdb.set_trace()
     response = get_litellm_response(
         prompt + context_str,
         messages=messages,
@@ -218,6 +233,7 @@ def get_llm_response(
         images=images,
         attachments=attachments,
         stream=stream,
+        include_usage=include_usage,
         **kwargs,
     )
     return response
@@ -254,7 +270,7 @@ def execute_llm_command(
     attempt = 0
     subcommands = []
 
-    # Create context from retrieved documents
+   
     context = ""
     while attempt < max_attempts:
         prompt = f"""
@@ -297,7 +313,7 @@ def execute_llm_command(
                 """
 
             messages.append({"role": "user", "content": prompt})
-            # print(messages, stream)
+           
             response = get_llm_response(
                 prompt,
                 model=model,
@@ -363,7 +379,6 @@ def execute_llm_command(
         "messages": messages,
         "output": "Max attempts reached. Unable to execute the command successfully.",
     }
-
 def handle_jinx_call(
     command: str,
     jinx_name: str,
@@ -376,6 +391,7 @@ def handle_jinx_call(
     n_attempts=3,
     attempt=0,
     context=None,
+    extra_globals=None,  # ADD THIS
     **kwargs
 ) -> Union[str, Dict[str, Any]]:
     """This function handles a jinx call.
@@ -396,8 +412,8 @@ def handle_jinx_call(
         return f"No jinxs are available. "
     else:
 
-        #print(npc, team)
-        #print(team.jinxs_dict, npc.jinxs_dict)
+       
+       
         if jinx_name not in npc.jinxs_dict and jinx_name not in team.jinxs_dict:
             print(f"Jinx {jinx_name} not available")
             if attempt < n_attempts:
@@ -502,25 +518,25 @@ def handle_jinx_call(
                     response_text.replace("```json", "").replace("```", "").strip()
                 )
 
-            # Parse the cleaned response
+           
             if isinstance(response_text, dict):
                 input_values = response_text
             else:
                 input_values = json.loads(response_text)
-            # print(f"Extracted inputs: {input_values}")
+           
         except json.JSONDecodeError as e:
             print(f"Error decoding input values: {e}. Raw response: {response}")
             return f"Error extracting inputs for jinx '{jinx_name}'"
-        # Input validation (example):
+       
         required_inputs = jinx.inputs
         missing_inputs = []
         for inp in required_inputs:
             if not isinstance(inp, dict):
-                # dicts contain the keywords so its fine if theyre missing from the inputs.
+               
                 if inp not in input_values or input_values[inp] == "":
                     missing_inputs.append(inp)
         if len(missing_inputs) > 0:
-            # print(f"Missing required inputs for jinx '{jinx_name}': {missing_inputs}")
+           
             if attempt < n_attempts:
                 print(f"attempt {attempt+1} to generate inputs failed, trying again")
                 print("missing inputs", missing_inputs)
@@ -553,6 +569,8 @@ def handle_jinx_call(
                 jinja_env,
                 npc=npc,
                 messages=messages,
+                extra_globals=extra_globals  # ADD THIS
+                
             )
         except Exception as e:
             print(f"An error occurred while executing the jinx: {e}")
@@ -576,7 +594,7 @@ def handle_jinx_call(
             render_markdown(f""" ## jinx OUTPUT FROM CALLING {jinx_name} \n \n output:{jinx_output['output']}""" )            
             response = get_llm_response(f"""
                 The user had the following request: {command}. 
-                Here were the jinx outputs from calling {jinx_name}: {jinx_output}
+                Here were the jinx outputs from calling {jinx_name}: {jinx_output.get('output', '')}
                 
                 Given the jinx outputs and the user request, please format a simple answer that 
                 provides the answer without requiring the user to carry out any further steps.
@@ -635,8 +653,8 @@ def handle_request_input(
     )
     return user_input
 
-### Following functions primarily support check_llm_command's procedure which was
-### broken up into smaller functions for clarity and modularity.
+
+
 
 
 def jinx_handler(command, extracted_data, **kwargs):
@@ -649,10 +667,10 @@ def jinx_handler(command, extracted_data, **kwargs):
         api_key=kwargs.get('api_key'),
         messages=kwargs.get('messages'),
         npc=kwargs.get('npc'),
-        team = kwargs.get('team'),
+        team=kwargs.get('team'),
         stream=kwargs.get('stream'),
-
-        context=kwargs.get('context')
+        context=kwargs.get('context'),
+        extra_globals=kwargs.get('extra_globals')  # ADD THIS
     )
 
 def answer_handler(command, extracted_data, **kwargs):
@@ -699,6 +717,7 @@ def check_llm_command(
     stream=False,
     context=None,
     actions: Dict[str, Dict] = None,
+    extra_globals=None,
 ):
     """This function checks an LLM command and returns sequences of steps with parallel actions."""
     if messages is None:
@@ -719,11 +738,12 @@ def check_llm_command(
         stream=stream,
         context=context,
         actions=actions,
+        extra_globals=extra_globals,
 
     )
     return exec
 
-# Define `DEFAULT_ACTION_SPACE`
+
 
 
 def jinx_context_filler(npc, team):
@@ -737,7 +757,7 @@ def jinx_context_filler(npc, team):
     Returns:
         str: Formatted string containing jinx information and usage guidelines
     """
-    # Generate NPC jinxs listing
+  
     npc_jinxs = "\nNPC Jinxs:\n" + (
         "\n".join(
             f"- {name}: {jinx.description}"
@@ -747,7 +767,7 @@ def jinx_context_filler(npc, team):
         else ''
     )
     
-    # Generate team jinxs listing
+  
     team_jinxs = "\n\nTeam Jinxs:\n" + (
         "\n".join(
             f"- {name}: {jinx.description}"
@@ -757,7 +777,7 @@ def jinx_context_filler(npc, team):
         else ''
     )
     
-    # Guidelines for jinx usage
+  
     usage_guidelines = """
 Use jinxs when appropriate. For example:
 
@@ -817,7 +837,7 @@ DEFAULT_ACTION_SPACE = {
             }
         }
     },
-    "answer_question": {
+    "answer": {
         "description": "Provide a direct informative answer",
         "handler": answer_handler,
         "context": """For general questions, use existing knowledge. For most queries a single action to answer a question will be sufficient.
@@ -826,7 +846,7 @@ e.g.
 {
     "actions": [
         {
-            "action": "answer_question",
+            "action": "answer",
             "explanation": "Provide a direct answer to the user's question based on existing knowledge."
             
     
@@ -839,7 +859,7 @@ Starting dialogue is usually more useful than using tools willynilly. Think care
 the user's intent and use this action as an opportunity to clear up potential ambiguities before
 proceeding to more complex actions.
 For example, if a user requests to write a story, 
-it is better to respond with 'answer_question'  and to write them a story rather than to invoke some tool.
+it is better to respond with 'answer'  and to write them a story rather than to invoke some tool.
 Indeed, it might be even better to respond and to request clarification about what other elements they would liek to specify with the story.
 Natural language is highly ambiguous and it is important to establish common ground and priorities before proceeding to more complex actions.
 
@@ -858,6 +878,7 @@ def plan_multi_step_actions(
    api_key: str = None,
    context: str = None,
    messages: List[Dict[str, str]] = None,
+   
 
 ):
     """
@@ -873,12 +894,13 @@ Your task is to create a complete, sequential JSON plan to fulfill the entire re
 Use the following context about available actions and tools to construct the plan.
 
 """
-
+    if messages == None:
+        messages = list()
     for action_name, action_info in actions.items():
         ctx = action_info.get("context")
         if callable(ctx):
             try:
-                #print(ctx)
+              
                 ctx = ctx(npc=npc, team=team)
             except Exception as e:
                 print( actions)
@@ -938,8 +960,8 @@ Respond ONLY with the plan.
         context=context,
     )
     response_content = action_response.get("response", {})
-    #print(action_response)
-    #print(type(action_response))
+  
+  
     return response_content.get("actions", [])
 
 def execute_multi_step_plan(
@@ -963,7 +985,7 @@ def execute_multi_step_plan(
     between steps for adaptive behavior.
     """
     
-    # 1. Get the complete plan upfront with the corrected call.
+  
     planned_actions = plan_multi_step_actions(
         command=command,
         actions=actions,
@@ -976,6 +998,7 @@ def execute_multi_step_plan(
         messages=messages,
         team=team, 
         
+        
     )
     
     if not planned_actions:
@@ -991,7 +1014,8 @@ def execute_multi_step_plan(
                                 stream=stream,
                                 team = team, 
                                 images=images, 
-                                context=context)
+                                context=context
+                                )
         return {"messages": result.get('messages',
                                        messages), 
                 "output": result.get('response')}
@@ -999,7 +1023,7 @@ def execute_multi_step_plan(
 
     step_outputs = []
     current_messages = messages.copy()
-    render_markdown(f"### Plan for Command: {command[100:]}")
+    render_markdown(f"### Plan for Command: {command[:100]}")
     for action in planned_actions:
         step_info = json.dumps({'action': action.get('action', ''), 
                                 'explanation': str(action.get('explanation',''))[0:10]+'...'})
@@ -1010,39 +1034,60 @@ def execute_multi_step_plan(
     for i, action_data in enumerate(planned_actions):
         render_markdown(f"--- Executing Step {i + 1} of {len(planned_actions)} ---")
         action_name = action_data["action"]
-        handler = actions[action_name]["handler"]
-        
-        # re-implement the yielding
-        step_context = f"Context from previous steps: {json.dumps(step_outputs)}" if step_outputs else ""
-        render_markdown(
-            f"- Executing Action: {action_name} \n- Explanation: {action_data.get('explanation')}\n "
-        )
-        
-        result = handler(
-           command=command, 
-           extracted_data=action_data,
-           model=model,
-           provider=provider, 
-           api_url=api_url,
-           api_key=api_key, 
-           messages=current_messages, 
-           npc=npc,
-           team=team,
-           stream=stream, 
-
-           context=context+step_context, 
-           images=images
-        )
+      
+          
+        try:
+            handler = actions[action_name]["handler"]
 
 
+          
+            step_context = f"Context from previous steps: {json.dumps(step_outputs)}" if step_outputs else ""
+            render_markdown(
+                f"- Executing Action: {action_name} \n- Explanation: {action_data.get('explanation')}\n "
+            )
+                            
+            result = handler(
+                command=command, 
+                extracted_data=action_data,
+                model=model,
+                provider=provider, 
+                api_url=api_url,
+                api_key=api_key, 
+                messages=current_messages, 
+                npc=npc,
+                team=team,
+                stream=stream, 
+                context=context+step_context, 
+                images=images,
+                extra_globals=kwargs.get('extra_globals')  # ADD THIS
+            )
+        except KeyError as e:
+          
+            return execute_multi_step_plan(
+                                            command=command + 'This error occurred: '+str(e)+'\n Do not make the same mistake again. If you are intending to use a jinx, you must `invoke_jinx`. If you just need to answer, choose `answer`.',
+                                            model= model,
+                                            provider = provider,
+                                            api_url = api_url,
+                                            api_key = api_key,
+                                            npc = npc,
+                                            team = team,
+                                            messages = messages,
+                                            images = images,
+                                            stream=stream,
+                                            context=context,
+                                            actions=actions,
+                                            
+                                            **kwargs, 
+            )
+
         action_output = result.get('output') or result.get('response')
         
         if stream and len(planned_actions) > 1:
-            # If streaming, we need to process the output with markdown rendering
+          
             action_output = print_and_process_stream_with_markdown(action_output, model, provider)
         elif len(planned_actions) == 1:
-            # If streaming and only one action, we can directly return the output
-            # can circumvent because compile sequence results just returns single output results.
+          
+          
             return {"messages": result.get('messages', 
                                            current_messages), 
                     "output": action_output}
@@ -1050,8 +1095,8 @@ def execute_multi_step_plan(
         current_messages = result.get('messages', 
                                       current_messages)
 
-    # render_markdown('## Reviewing output...')
-    # need tot replace with a review step actually 
+  
+  
     final_output = compile_sequence_results(
        original_command=command,
        outputs=step_outputs,
@@ -1109,7 +1154,7 @@ Final Synthesized Response that addresses the user in a polite and informative m
     synthesized = response.get("response", "")
     if synthesized:
         return synthesized    
-    return '\n'.join(outputs)  # Fallback to joining outputs if synthesis fails
+    return '\n'.join(outputs)
 
 
 
@@ -1176,8 +1221,8 @@ JSON response:
 
 
 
-### Functions for knowledge extraction using get_llm_response
-### primarily used in memory.knowledge_graph but are general enough
+
+
 
 
 
@@ -1318,7 +1363,7 @@ def generate_group_candidates(
         else:
             item_subset = items
         
-        # --- PROMPT MODIFICATION: Focus on semantic essence, avoid gerunds/adverbs, favor subjects ---
+      
         prompt = f"""From the following {item_type}, identify specific and relevant conceptual groups.
         Think about the core subject or entity being discussed.
         
@@ -1345,7 +1390,7 @@ def generate_group_candidates(
             "groups": ["list of specific, precise, and relevant group names"]
         }}
         """
-        # --- END PROMPT MODIFICATION ---
+      
         
         response = get_llm_response(
             prompt,
@@ -1547,7 +1592,7 @@ def extract_facts(
     context: str = None
 ) -> List[str]:
     """Extract concise facts from text using LLM (as defined earlier)"""
-    # Implementation from your previous code
+  
     prompt = """Extract concise facts from this text.
         A fact is a piece of information that makes a statement about the world.
         A fact is typically a sentence that is true or false.
@@ -1642,6 +1687,9 @@ def get_facts(content_text,
               provider = None,
               npc=None,
               context : str=None, 
+              attempt_number=1,
+              n_attempts=3,
+
               **kwargs):
     """Extract facts from content text"""
     
@@ -1744,6 +1792,17 @@ def get_facts(content_text,
                                 context=context,
                                 **kwargs)
 
+    if len(response.get("response", {}).get("facts", [])) == 0 and attempt_number < n_attempts:
+        print(f"  Attempt {attempt_number} to extract facts yielded no results. Retrying...")
+        return get_facts(content_text, 
+                         model=model, 
+                         provider=provider, 
+                         npc=npc,
+                         context=context,
+                         attempt_number=attempt_number+1,
+                         n_attempts=n_attempts,
+                         **kwargs)
+    
     return response["response"].get("facts", [])
 
         
@@ -1753,6 +1812,8 @@ def zoom_in(facts,
             provider=None, 
             npc=None,
             context: str = None, 
+            attempt_number: int = 1,
+            n_attempts=3,            
             **kwargs):
     """Infer new implied facts from existing facts"""
     valid_facts = []
@@ -1773,16 +1834,16 @@ def zoom_in(facts,
     {facts_text}
 
     What other facts can be reasonably inferred from these?
-
+    """ +"""
     Respond with JSON:
-    {{
+    {
         "implied_facts": [
-            {{
+            {
                 "statement": "new implied fact",
                 "inferred_from": ["which facts this comes from"]
-            }}
+            }
         ]
-    }}
+    }
     """
     
     response = get_llm_response(prompt, 
@@ -1792,7 +1853,18 @@ def zoom_in(facts,
                                 context=context,
                                 npc=npc,
                                 **kwargs)
-    return response["response"].get("implied_facts", [])
+
+    facts =  response.get("response", {}).get("implied_facts", [])
+    if len(facts) == 0:
+        return zoom_in(valid_facts, 
+                       model=model, 
+                       provider=provider, 
+                       npc=npc,
+                       context=context,
+                       attempt_number=attempt_number+1,
+                       n_tries=n_tries,
+                       **kwargs)
+    return facts
 def generate_groups(facts, 
                     model=None,
                     provider=None,
@@ -1961,7 +2033,10 @@ def get_related_facts_llm(new_fact_statement,
                           model = None, 
                           provider = None,
                           npc = None, 
-                          context=''):
+                          attempt_number = 1,
+                          n_attempts = 3,
+                          context='', 
+                          **kwargs):
     """Identifies which existing facts are causally or thematically related to a new fact."""
     prompt = f"""
     A new fact has been learned: "{new_fact_statement}"
@@ -1974,12 +2049,25 @@ def get_related_facts_llm(new_fact_statement,
 
     Respond with JSON: {{"related_facts": ["statement of a related fact", ...]}}
     """
-    response = get_llm_response(prompt, 
+    response = get_llm_response(prompt,
                                 model=model, 
                                 provider=provider, 
-                                npc = npc,
                                 format="json", 
-                                context=context)
+                                npc=npc,
+                                context=context,
+                                **kwargs)   
+    if attempt_number > n_attempts:
+        print(f"  Attempt {attempt_number} to find related facts yielded no results. Giving up.")
+        return get_related_facts_llm(new_fact_statement, 
+                                       existing_fact_statements, 
+                                       model=model, 
+                                       provider=provider, 
+                                       npc=npc,
+                                       attempt_number=attempt_number+1,
+                                       n_attempts=n_attempts,
+                                       context=context,
+                                       **kwargs)    
+
     return response["response"].get("related_facts", [])
 
 def find_best_link_concept_llm(candidate_concept_name, 
@@ -2044,4 +2132,284 @@ def asymptotic_freedom(parent_concept,
                                 format="json", 
                                 context=context, npc=npc,
                                 **kwargs)
-    return response['response'].get('new_sub_concepts', [])
+    return response['response'].get('new_sub_concepts', [])
+
+
+
+def bootstrap(
+    prompt: str,
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    sample_params: Dict[str, Any] = None,
+    sync_strategy: str = "consensus",
+    context: str = None,
+    n_samples: int = 3,
+    **kwargs
+) -> Dict[str, Any]:
+    """Bootstrap by sampling multiple agents from team or varying parameters"""
+    
+    if team and hasattr(team, 'npcs') and len(team.npcs) >= n_samples:
+      
+        sampled_npcs = list(team.npcs.values())[:n_samples]
+        results = []
+        
+        for i, agent in enumerate(sampled_npcs):
+            response = get_llm_response(
+                f"Sample {i+1}: {prompt}\nContext: {context}",
+                npc=agent,
+                context=context,
+                **kwargs
+            )
+            results.append({
+                'agent': agent.name,
+                'response': response.get("response", "")
+            })
+    else:
+      
+        if sample_params is None:
+            sample_params = {"temperature": [0.3, 0.7, 1.0]}
+        
+        results = []
+        for i in range(n_samples):
+            temp = sample_params.get('temperature', [0.7])[i % len(sample_params.get('temperature', [0.7]))]
+            response = get_llm_response(
+                f"Sample {i+1}: {prompt}\nContext: {context}",
+                model=model,
+                provider=provider,
+                npc=npc,
+                temperature=temp,
+                context=context,
+                **kwargs
+            )
+            results.append({
+                'variation': f'temp_{temp}',
+                'response': response.get("response", "")
+            })
+    
+  
+    response_texts = [r['response'] for r in results]
+    return synthesize(response_texts, sync_strategy, model, provider, npc or (team.forenpc if team else None), context)
+
+def harmonize(
+    prompt: str,
+    items: List[str],
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    harmony_rules: List[str] = None,
+    context: str = None,
+    agent_roles: List[str] = None,
+    **kwargs
+) -> Dict[str, Any]:
+    """Harmonize using multiple specialized agents"""
+    
+    if team and hasattr(team, 'npcs'):
+      
+        available_agents = list(team.npcs.values())
+        
+        if agent_roles:
+          
+            selected_agents = []
+            for role in agent_roles:
+                matching_agent = next((a for a in available_agents if role.lower() in a.name.lower() or role.lower() in a.primary_directive.lower()), None)
+                if matching_agent:
+                    selected_agents.append(matching_agent)
+            agents_to_use = selected_agents or available_agents[:len(items)]
+        else:
+          
+            agents_to_use = available_agents[:min(len(items), len(available_agents))]
+        
+        harmonized_results = []
+        for i, (item, agent) in enumerate(zip(items, agents_to_use)):
+            harmony_prompt = f"""Harmonize this element: {item}
+Task: {prompt}
+Rules: {', '.join(harmony_rules or ['maintain_consistency'])}
+Context: {context}
+Your role in harmony: {agent.primary_directive}"""
+            
+            response = get_llm_response(
+                harmony_prompt,
+                npc=agent,
+                context=context,
+                **kwargs
+            )
+            harmonized_results.append({
+                'agent': agent.name,
+                'item': item,
+                'harmonized': response.get("response", "")
+            })
+        
+      
+        coordinator = team.get_forenpc() if team else npc
+        synthesis_prompt = f"""Synthesize these harmonized elements:
+{chr(10).join([f"{r['agent']}: {r['harmonized']}" for r in harmonized_results])}
+Create unified harmonious result."""
+        
+        return get_llm_response(synthesis_prompt, npc=coordinator, context=context, **kwargs)
+    
+    else:
+      
+        items_text = chr(10).join([f"{i+1}. {item}" for i, item in enumerate(items)])
+        harmony_prompt = f"""Harmonize these items: {items_text}
+Task: {prompt}
+Rules: {', '.join(harmony_rules or ['maintain_consistency'])}
+Context: {context}"""
+        
+        return get_llm_response(harmony_prompt, model=model, provider=provider, npc=npc, context=context, **kwargs)
+
+def orchestrate(
+    prompt: str,
+    items: List[str],
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    workflow: str = "sequential_coordination",
+    context: str = None,
+    **kwargs
+) -> Dict[str, Any]:
+    """Orchestrate using team.orchestrate method"""
+    
+    if team and hasattr(team, 'orchestrate'):
+      
+        orchestration_request = f"""Orchestrate workflow: {workflow}
+Task: {prompt}
+Items: {chr(10).join([f'- {item}' for item in items])}
+Context: {context}"""
+        
+        return team.orchestrate(orchestration_request)
+    
+    else:
+      
+        items_text = chr(10).join([f"{i+1}. {item}" for i, item in enumerate(items)])
+        orchestrate_prompt = f"""Orchestrate using {workflow}:
+Task: {prompt}
+Items: {items_text}
+Context: {context}"""
+        
+        return get_llm_response(orchestrate_prompt, model=model, provider=provider, npc=npc, context=context, **kwargs)
+
+def spread_and_sync(
+    prompt: str,
+    variations: List[str],
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    sync_strategy: str = "consensus",
+    context: str = None,
+    **kwargs
+) -> Dict[str, Any]:
+    """Spread across agents/variations then sync with distribution analysis"""
+    
+    if team and hasattr(team, 'npcs') and len(team.npcs) >= len(variations):
+      
+        agents = list(team.npcs.values())[:len(variations)]
+        results = []
+        
+        for variation, agent in zip(variations, agents):
+            variation_prompt = f"""Analyze from {variation} perspective:
+Task: {prompt}
+Context: {context}
+Apply your expertise with {variation} approach."""
+            
+            response = get_llm_response(variation_prompt, npc=agent, context=context, **kwargs)
+            results.append({
+                'agent': agent.name,
+                'variation': variation,
+                'response': response.get("response", "")
+            })
+    else:
+      
+        results = []
+        agent = npc or (team.get_forenpc() if team else None)
+        
+        for variation in variations:
+            variation_prompt = f"""Analyze from {variation} perspective:
+Task: {prompt}
+Context: {context}"""
+            
+            response = get_llm_response(variation_prompt, model=model, provider=provider, npc=agent, context=context, **kwargs)
+            results.append({
+                'variation': variation,
+                'response': response.get("response", "")
+            })
+    
+  
+    response_texts = [r['response'] for r in results]
+    return synthesize(response_texts, sync_strategy, model, provider, npc or (team.get_forenpc() if team else None), context)
+
+def criticize(
+    prompt: str,
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    context: str = None,
+    **kwargs
+) -> Dict[str, Any]:
+    """Provide critical analysis and constructive criticism"""
+    critique_prompt = f"""
+    Provide a critical analysis and constructive criticism of the following:
+    {prompt}
+    
+    Focus on identifying weaknesses, potential improvements, and alternative approaches.
+    Be specific and provide actionable feedback.
+    """
+    
+    return get_llm_response(
+        critique_prompt,
+        model=model,
+        provider=provider,
+        npc=npc,
+        team=team,
+        context=context,
+        **kwargs
+    )
+def synthesize(
+    prompt: str,
+    model: str = None,
+    provider: str = None,
+    npc: Any = None,
+    team: Any = None,
+    context: str = None,
+    **kwargs
+) -> Dict[str, Any]:
+    """Synthesize information from multiple sources or perspectives"""
+    
+    # Extract responses from kwargs if provided, otherwise use prompt as single response
+    responses = kwargs.get('responses', [prompt])
+    sync_strategy = kwargs.get('sync_strategy', 'consensus')
+    
+    # If we have multiple responses, create a synthesis prompt
+    if len(responses) > 1:
+        synthesis_prompt = f"""Synthesize these multiple perspectives:
+        
+        {chr(10).join([f'Response {i+1}: {r}' for i, r in enumerate(responses)])}
+        
+        Synthesis strategy: {sync_strategy}
+        Context: {context}
+        
+        Create a coherent synthesis that incorporates key insights from all perspectives."""
+    else:
+        # For single response, just summarize/refine it
+        synthesis_prompt = f"""Refine and synthesize this content:
+        
+        {responses[0]}
+        
+        Context: {context}
+        
+        Create a clear, concise synthesis that captures the essence of the content."""
+    
+    return get_llm_response(
+        synthesis_prompt,
+        model=model,
+        provider=provider,
+        npc=npc,
+        team=team,
+        context=context,
+        **kwargs
+    )