iointel 1.0.0__py3-none-any.whl

iointel/__init__.py

@@ -0,0 +1,25 @@
+
+from .src.agents import Agent
+from .src.memory import AsyncMemory, AsyncPostgresMemoryProvider, Memory, PostgresMemoryProvider
+from .src.workflow import Workflow, run_agents
+from .src.agent_methods.data_models.datamodels import PersonaConfig
+from .src.handlers import AsyncLoggingHandler, LoggingHandler
+from .client import client
+
+
+__all__ = [
+    "Agent",
+    "AsyncMemory",
+    "AsyncPostgresMemoryProvider",
+    "Memory",
+    "PostgresMemoryProvider",
+    "Workflow",
+    "run_agents",
+    "PersonaConfig",
+    "AsyncLoggingHandler",
+    "LoggingHandler",
+    "client"
+]
+
+
+__version__="1.0.0"

iointel/client/client.py

@@ -0,0 +1,168 @@
+import requests
+import os
+import time
+from typing import Optional, List
+from functools import partial
+
+BASE_URL = os.getenv("OPENAI_API_BASE_URL", "").rstrip("/")
+API_KEY = os.getenv("OPENAI_API_KEY")
+BASE_MCP_URL = os.getenv("BASE_MCP_URL")
+try:
+    SLOW_MODE_SLEEP = int(os.getenv("SLOW_MODE_SLEEP"))
+except (ValueError, TypeError):
+    SLOW_MODE_SLEEP = -1
+
+def __make_api_call(method, **kwargs) -> dict:
+    start = time.time()
+    url = kwargs.pop("url", f"{BASE_URL}/workflows/run")
+    headers = kwargs.pop("headers", {})
+    if "Authorization" not in headers:
+        headers["Authorization"] = f"Bearer {API_KEY}"
+    response = requests.request(method, url, headers=headers, **kwargs)
+    response.raise_for_status()
+    result = response.json()
+    if (remain := SLOW_MODE_SLEEP - (time.time() - start)) > 0:
+        # HACK avoid triggering rate limit protection if told so
+        # by making sure each `__make_api_call()` takes at least `SLOW_MODE_SLEEP` seconds
+        time.sleep(remain)
+    return result
+__make_post_call = partial(__make_api_call, method="POST")
+__make_get_call = partial(__make_api_call, method="GET")
+
+
+def schedule_task(task: str) -> dict:
+    raise NotImplementedError()
+    # payload = {"task": task}
+    # return __make_post_call(json=payload)
+
+def run_council_task(task: str) -> dict:
+    raise NotImplementedError()
+    # return __make_post_call(json=payload)
+
+def run_reasoning_task(text: str) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["reasoning_agent"],
+        "args": {
+            "type": "solve_with_reasoning"
+        }
+    }
+    return __make_post_call(json=payload)
+
+def summarize_task(text: str) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["summary_agent"],
+        "args": {
+            "type": "summarize_text"
+        }
+    }
+    return __make_post_call(json=payload)
+
+def sentiment_analysis(text: str) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["sentiment_analysis_agent"],
+        "args": {
+            "type": "sentiment"
+        }
+    }
+    return __make_post_call(json=payload)
+
+def extract_entities(text: str) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["extractor"],
+        "args": {
+            "type": "extract_categorized_entities"
+        }
+    }
+    return __make_post_call(json=payload)
+
+def translate_text_task(text: str, target_language: str) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["translation_agent"],
+        "args": {
+            "type": "translate_text",
+            "target_language": target_language
+        }
+    }
+    return __make_post_call(json=payload)
+
+def classify_text(text: str, classify_by: list[str]) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["classification_agent"],
+        "args": {
+            "type": "classify",
+            "classify_by": classify_by
+        }
+    }
+    return __make_post_call(json=payload)
+
+def moderation_task(text: str, threshold: float = 0.5) -> dict:
+    payload = {
+        "text": text,
+        "agent_names": ["moderation_agent"],
+        "args": {
+            "type": "moderation",
+            "threshold": threshold
+        }
+    }
+    return __make_post_call(json=payload)
+
+def custom_workflow(
+        text: str,
+        name: str, 
+        objective: str, 
+        instructions: str = "", 
+        agents: Optional[List[str]] = None,
+        context: Optional[dict] = None
+        ) -> dict:
+
+    payload = {
+        "text": text,
+        "agent_names": agents or ["custom_agent"],
+        "args": {
+            "type": "custom",
+            "name": name,
+            "objective": objective,
+            "instructions": instructions,
+            "context": context or {},
+        }
+    }
+    return __make_post_call(json=payload)
+
+def get_tools() -> dict:
+    response = requests.get(f"{BASE_MCP_URL}/mcp/tools")
+    response.raise_for_status()
+    return response.json()
+
+def get_servers() -> dict:
+    response = requests.get(f"{BASE_MCP_URL}/mcp/servers")
+    response.raise_for_status()
+    return response.json()
+
+def get_agents() -> dict:
+    return __make_get_call(url=f"{BASE_URL}/agents/")
+
+def upload_workflow_file(file_path: str) -> dict:
+    """
+    Uploads a workflow file to the server.
+    This file may contain either JSON or YAML content, which the server
+    will parse and validate as a WorkflowDefinition.
+
+    :param file_path: Local path to the file to upload.
+    :return: JSON response from the server as a dict.
+    :raises: HTTPError if the request fails.
+    """
+
+    raise NotImplementedError()
+    # with open(file_path, "rb") as f:
+    #     return __make_post_call(
+    #         url=f"{BASE_URL}/workflows/run-file",
+    #         files={"yaml_file": 
+    #                (os.path.basename(file_path), 
+    #                 f, 
+    #                 "application/octet-stream")})

iointel/src/agent_methods/agents/agents_factory.py

@@ -0,0 +1,111 @@
+import os
+
+from iointel import Agent
+from ..data_models.datamodels import AgentParams
+from typing import Optional
+
+
+
+AGENT_SPECS = {
+    "reminder_agent": {
+        "name": "Reminder Agent",
+        "instructions": "A simple agent that sends reminders."
+    },
+    "leader": {
+        "name": "Leader",
+        "instructions": """
+            You are the council leader, 
+            you lead the council and provide guidance, 
+            and administer the voting process.
+        """
+    },
+    "council_member1": {
+        "name": "Council Member 1",
+        "instructions": "You are a council member who provides input and votes on decisions."
+    },
+    "council_member2": {
+        "name": "Council Member 2",
+        "instructions": "You are a council member who provides input and votes on decisions."
+    },
+    "council_member3": {
+        "name": "Council Member 3",
+        "instructions": "You are a council member who provides input and votes on decisions."
+    },
+    "coder": {
+        "name": "Coder",
+        "instructions": "You are an expert python coder who provides code for the task."
+    },
+    "agent_maker": {
+        "name": "Agent Maker",
+        "instructions": "You create agents that can perform tasks from the provided code."
+    },
+    "reasoning_agent": {
+        "name": "Reasoning Agent",
+        "instructions": "You are an agent that performs reasoning steps."
+    },
+    "docker_sandbox_agent": {
+        "name": "Docker Sandbox Agent",
+        "instructions": "You are an agent that runs code in a docker sandbox."
+    },
+    "summary_agent": {
+        "name": "Summary Agent",
+        "instructions": "You are an agent that summarizes text."
+    },
+    "sentiment_analysis_agent": {
+        "name": "Sentiment Analysis Agent",
+        "instructions": "You are an agent that performs unbiased sentiment analysis on text."
+    },
+    "extractor": {
+        "name": "Named Entity Recognizer",
+        "instructions": "You are an agent that extracts named entities from text."
+    },
+    "default_agent": {
+        "name": "Default Agent",
+        "instructions": "You are an agent that does a lot of different things, you are dynamic."
+    },
+    "moderation_agent": {
+        "name": "Moderation Agent",
+        "instructions": "You are an agent that moderates content."
+    },
+    "classification_agent": {
+        "name": "Classification Agent",
+        "instructions": "You are an agent that is an expert in classifying things."
+    },
+    "translation_agent": {
+        "name": "Translation Agent",
+        "instructions": "You are an agent that is a polyglot of multiple languages and is an expert in translating text."
+    },
+}
+
+def create_agent(params: AgentParams) -> Agent:
+    """
+    Create a Agent instance from the given AgentParams.
+    """
+    #return Agent(name=params.name, instructions=params.instructions, persona=params.persona, tools=params.tools)
+    return Agent(**params.model_dump(exclude_none=True))
+
+def create_agents():
+    return {
+        agent_key: create_agent(
+            AgentParams(
+                name=spec["name"],
+                instructions=spec["instructions"]
+            )
+        )
+        for agent_key, spec in AGENT_SPECS.items()
+    }
+
+
+AGENTS = create_agents() if os.environ.get('LIBRARY_MODE', '').lower() != 'true' else {}
+
+
+def get_agent(agent_name: str, agent_params: Optional[AgentParams] = None) -> Agent:
+    if agent_params is None:
+        agent_params = AgentParams(name="", instructions="")
+
+    # Merge or set the default name/instructions
+    spec = AGENT_SPECS.get(agent_name, AGENT_SPECS["default_agent"])
+    agent_params.name = agent_params.name or spec["name"]
+    agent_params.instructions = agent_params.instructions or spec["instructions"]
+
+    return create_agent(agent_params)

iointel/src/agent_methods/data_models/datamodels.py

@@ -0,0 +1,333 @@
+import sys
+from pydantic import BaseModel, Field
+from typing import List, Annotated, Optional,Union, Callable
+from datetime import datetime
+import controlflow
+from controlflow.memory.memory import Memory
+from controlflow.memory.async_memory import AsyncMemory
+if sys.version_info < (3, 12):
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+class PersonaConfig(BaseModel):
+    """
+    A configuration object that describes an agent's persona or character.
+    """
+    name: Optional[str] = Field(
+        None,
+        description="If the persona has a specific name or nickname."
+    )
+    age: Optional[int] = Field(
+        None,
+        description="Approximate age of the persona (if relevant).",
+        ge=1
+    )
+    role: Optional[str] = Field(
+        None,
+        description="General role or type, e.g. 'a brave knight', 'a friendly teacher', etc."
+    )
+    style: Optional[str] = Field(
+        None,
+        description="A short description of the agent's style or demeanor (e.g., 'formal and polite')."
+    )
+    domain_knowledge: List[str] = Field(
+        default_factory=list,
+        description="List of domains or special areas of expertise the agent has."
+    )
+    quirks: Optional[str] = Field(
+        None,
+        description="Any unique quirks or mannerisms, e.g. 'likes using puns' or 'always references coffee.'"
+    )
+    bio: Optional[str] = Field(
+        None,
+        description="A short biography or personal background for the persona."
+    )
+    lore: Optional[str] = Field(
+        None,
+        description="In-universe lore or backstory, e.g. 'grew up in a small village with magical powers.'"
+    )
+    personality: Optional[str] = Field(
+        None,
+        description="A more direct statement of the persona's emotional or psychological traits."
+    )
+    conversation_style: Optional[str] = Field(
+        None,
+        description="How the character speaks in conversation, e.g., 'often uses slang' or 'very verbose and flowery.'"
+    )
+    description: Optional[str] = Field(
+        None,
+        description="A general descriptive text, e.g., 'A tall, lean figure wearing a cloak, with a stern demeanor.'"
+    )
+
+    friendliness: Optional[float] = Field(
+        None,
+        description="How friendly the agent is, from 0 (hostile) to 1 (friendly).",
+        ge=0,
+        le=1
+    )
+    creativity: Optional[float] = Field(
+        None,
+        description="How creative the agent is, from 0 (very logical) to 1 (very creative).",
+        ge=0,
+        le=1
+    )
+    curiosity: Optional[float] = Field(
+        None,
+        description="How curious the agent is, from 0 (disinterested) to 1 (very curious).",        
+        ge=0,
+        le=1
+    )
+    empathy: Optional[float] = Field(
+        None,
+        description="How empathetic the agent is, from 0 (cold) to 1 (very empathetic).",
+        ge=0,
+        le=1
+    )
+    humor: Optional[float] = Field(
+        None,
+        description="How humorous the agent is, from 0 (serious) to 1 (very humorous).",
+        ge=0,
+        le=1
+    )
+    formality: Optional[float] = Field(
+        None,
+        description="How formal the agent is, from 0 (very casual) to 1 (very formal).",
+        ge=0,
+        le=1
+    )
+    emotional_stability: Optional[float] = Field(
+        None,
+        description="How emotionally stable the agent is, from 0 (very emotional) to 1 (very stable).",
+        ge=0,
+        le=1
+    )
+
+    def to_system_instructions(self) -> str:
+        """
+        Combine fields into a single string that can be appended to the system instructions.
+        Each field is optional; only non-empty fields get appended.
+        """
+        lines = []
+
+        # 1. Possibly greet with a name or reference it
+        if self.name:
+            lines.append(f"Your name is {self.name}.")
+
+        # 2. Age or approximate range
+        if self.age is not None:
+            lines.append(f"You are {self.age} years old (approximately).")
+
+        # 3. High-level role or type
+        if self.role:
+            lines.append(f"You are {self.role}.")
+
+        # 4. Style or demeanor
+        if self.style:
+            lines.append(f"Your style or demeanor is: {self.style}.")
+
+        # 5. Domain knowledge
+        if self.domain_knowledge:
+            knowledge_str = ", ".join(self.domain_knowledge)
+            lines.append(f"You have expertise or knowledge in: {knowledge_str}.")
+
+        # 6. Quirks
+        if self.quirks:
+            lines.append(f"You have the following quirks: {self.quirks}.")
+
+        # 7. Bio
+        if self.bio:
+            lines.append(f"Personal background: {self.bio}.")
+
+        # 8. Lore
+        if self.lore:
+            lines.append(f"Additional lore/backstory: {self.lore}.")
+
+        # 9. Personality
+        if self.personality:
+            lines.append(f"Your personality traits: {self.personality}.")
+
+        # 10. Conversation style
+        if self.conversation_style:
+            lines.append(f"In conversation, you speak in this style: {self.conversation_style}.")
+
+        # 11. General description
+        if self.description:
+            lines.append(f"General description: {self.description}.")
+        
+        # 12. Personality traits
+        if self.friendliness is not None:
+            lines.append(f"Your overall Friendliness from 0 to 1 is: {self.friendliness}")
+
+        if self.creativity is not None:
+            lines.append(f"Your overall Creativity from 0 to 1 is: {self.creativity}")
+
+        if self.curiosity is not None:
+            lines.append(f"Your overall Curiosity from 0 to 1 is: {self.curiosity}")
+
+        if self.empathy is not None:
+            lines.append(f"Your overall Empathy from 0 to 1 is: {self.empathy}")
+
+        if self.humor is not None:
+            lines.append(f"Your overall Humor from 0 to 1 is: {self.humor}")
+
+        if self.formality is not None:
+            lines.append(f"Your overall Formality from 0 to 1 is: {self.formality}")
+
+        if self.emotional_stability is not None:
+            lines.append(f"Your overall Emotional stability from 0 to 1 is: {self.emotional_stability}")
+
+        # Return them joined by newlines, or any separator you prefer
+        return "\n".join(lines)
+
+##agent params###
+class AgentParams(BaseModel):
+    name: str
+    instructions: str
+    description: Optional[str] = None
+    persona: Optional[PersonaConfig] = None
+    model: Optional[Callable] = None
+    tools: Optional[List[str]] | Optional[List[Callable]] = Field(default_factory=list)
+    llm_rules: Optional[controlflow.llm.rules.LLMRules] = None
+    interactive: Optional[bool] = False
+    memories: Optional[list[Memory]] | Optional[list[AsyncMemory]] = Field(default_factory=list)
+
+#reasoning agent
+class ReasoningStep(BaseModel):
+    explanation: str = Field(
+        description="""
+            A brief (<5 words) description of what you intend to
+            achieve in this step, to display to the user.
+            """
+    )
+    reasoning: str = Field(
+        description="A single step of reasoning, not more than 1 or 2 sentences."
+    )
+    found_validated_solution: bool
+
+
+##summary
+class SummaryResult(BaseModel):
+    summary: str
+    key_points: List[str]
+
+#translation
+class TranslationResult(BaseModel):
+    translated: str
+    target_language: str
+
+
+Activation = Annotated[float, Field(ge=0, le=1)]
+
+
+class ModerationException(Exception):
+    """Exception raised when a message is not allowed."""
+
+    ...
+
+
+class ViolationActivation(TypedDict):
+    """Violation activation."""
+
+    extreme_profanity: Annotated[Activation, Field(description="hell / damn are fine")]
+    sexually_explicit: Activation
+    hate_speech: Activation
+    harassment: Activation
+    self_harm: Activation
+    dangerous_content: Activation
+
+
+class WorkflowStep(BaseModel):
+    type: str
+    name: Optional[str] = None
+    objective: Optional[str] = None
+    instructions: Optional[str] = None
+    text: Optional[str] = None  # for this step’s prompt
+    context: Optional[dict] = None
+    target_language: Optional[str] = None
+
+class WorkflowDefinition(BaseModel):
+    """
+    The top-level structure of the YAML.
+    name: A human-readable name for the workflow
+    agents: The agent definitions
+    workflow: The list of steps
+    """
+    name: str
+    text: Optional[str] = None  # This holds the main text/prompt
+    agents: Optional[List[AgentParams]] = None
+    workflow: List[WorkflowStep] = Field(default_factory=list)
+
+
+
+### logging handlers
+
+class BaseEventModel(BaseModel):
+    """
+    A base model to capture common fields or structure for all events.
+    """
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+class AgentMessageEvent(BaseEventModel):
+    event_type: str = "agent_message"
+    agent_name: str
+    content: str
+
+class UserMessageEvent(BaseEventModel):
+    event_type: str = "user_message"
+    content: str
+
+class OrchestratorMessageEvent(BaseEventModel):
+    event_type: str = "orchestrator_message"
+    content: str
+
+class ToolCallEvent(BaseEventModel):
+    event_type: str = "tool_call"
+    tool_name: str
+
+class ToolResultEvent(BaseEventModel):
+    event_type: str = "tool_result"
+    tool_name: str
+    result: str
+
+class OrchestratorStartEvent(BaseEventModel):
+    event_type: str = "orchestrator_start"
+
+class OrchestratorEndEvent(BaseEventModel):
+    event_type: str = "orchestrator_end"
+
+class AgentMessageDeltaEvent(BaseEventModel):
+    event_type: str = "agent_message_delta"
+    delta: str
+
+class OrchestratorErrorEvent(BaseEventModel):
+    event_type: str = "orchestrator_error"
+    error: str
+
+class EndTurnEvent(BaseEventModel):
+    event_type: str = "end_turn"
+
+class CatchallEvent(BaseEventModel):
+    event_type: str = "catch-all"
+    details: dict = {}
+
+# Union of all event models
+EventModelUnion = Union[
+    AgentMessageEvent,
+    UserMessageEvent,
+    OrchestratorMessageEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    OrchestratorStartEvent,
+    OrchestratorEndEvent,
+    AgentMessageDeltaEvent,
+    OrchestratorErrorEvent,
+    EndTurnEvent,
+    CatchallEvent
+]
+
+class EventsLog(BaseModel):
+    """
+    Main aggregator for all events.
+    """
+    events: List[EventModelUnion] = []

iointel/src/agent_methods/prompts/instructions.py

@@ -0,0 +1,28 @@
+REASONING_INSTRUCTIONS = """
+    You are working on solving a difficult problem (the `goal`). Based
+    on your previous thoughts and the overall goal, please perform **one
+    reasoning step** that advances you closer to a solution. Document
+    your thought process and any intermediate steps you take.
+    
+    After marking this task complete for a single step, you will be
+    given a new reasoning task to continue working on the problem. The
+    loop will continue until you have a valid solution.
+    
+    Complete the task as soon as you have a valid solution.
+    
+    **Guidelines**
+    
+    - You will not be able to brute force a solution exhaustively. You
+        must use your reasoning ability to make a plan that lets you make
+        progress.
+    - Each step should be focused on a specific aspect of the problem,
+        either advancing your understanding of the problem or validating a
+        solution.
+    - You should build on previous steps without repeating them.
+    - Since you will iterate your reasoning, you can explore multiple
+        approaches in different steps.
+    - Use logical and analytical thinking to reason through the problem.
+    - Ensure that your solution is valid and meets all requirements.
+    - If you find yourself spinning your wheels, take a step back and
+        re-evaluate your approach.
+"""

iointel/src/agent_methods/tools/tools.py

@@ -0,0 +1,9 @@
+from datetime import datetime
+
+
+
+def get_current_datetime() -> str:
+    """
+    Return the current datetime as a string in YYYY-MM-DD HH:MM:SS format.
+    """
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")