jl-ecms-client 0.2.7__py3-none-any.whl → 0.2.19__py3-none-any.whl

mirix/settings.py

@@ -0,0 +1,280 @@
+import sys
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Load .env file if it exists before initializing settings
+# This ensures environment variables from .env are available when settings are instantiated
+load_dotenv()
+
+
+class ToolSettings(BaseSettings):
+    composio_api_key: Optional[str] = None
+
+    # E2B Sandbox configurations
+    e2b_api_key: Optional[str] = None
+    e2b_sandbox_template_id: Optional[str] = None  # Updated manually
+
+    # Local Sandbox configurations
+    local_sandbox_dir: Optional[str] = None
+
+
+class SummarizerSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="mirix_summarizer_", extra="ignore")
+
+    # Controls if we should evict all messages
+    # TODO: Can refactor this into an enum if we have a bunch of different kinds of summarizers
+    evict_all_messages: bool = False
+
+    # The maximum number of retries for the summarizer
+    # If we reach this cutoff, it probably means that the summarizer is not compressing down the in-context messages any further
+    # And we throw a fatal error
+    max_summarizer_retries: int = 3
+
+    # When to warn the model that a summarize command will happen soon
+    # The amount of tokens before a system warning about upcoming truncation is sent to Mirix
+    memory_warning_threshold: float = 0.75
+
+    # Whether to send the system memory warning message
+    send_memory_warning_message: bool = False
+
+    # The desired memory pressure to summarize down to
+    desired_memory_token_pressure: float = 0.1
+
+    # The number of messages at the end to keep
+    # Even when summarizing, we may want to keep a handful of recent messages
+    # These serve as in-context examples of how to use functions / what user messages look like
+    keep_last_n_messages: int = 5
+
+
+class ModelSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    # env_prefix='my_prefix_'
+
+    # openai
+    openai_api_key: Optional[str] = None
+    openai_api_base: str = "https://api.openai.com/v1"
+
+    # groq
+    groq_api_key: Optional[str] = None
+
+    # Bedrock
+    aws_access_key: Optional[str] = None
+    aws_secret_access_key: Optional[str] = None
+    aws_region: Optional[str] = None
+    bedrock_anthropic_version: Optional[str] = "bedrock-2023-05-31"
+
+    # anthropic
+    anthropic_api_key: Optional[str] = None
+
+    # ollama
+    ollama_base_url: Optional[str] = None
+
+    # azure
+    azure_api_key: Optional[str] = None
+    azure_base_url: Optional[str] = None
+    # We provide a default here, since usually people will want to be on the latest API version.
+    azure_api_version: Optional[str] = (
+        "2024-09-01-preview"  # https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
+    )
+
+    # google ai
+    gemini_api_key: Optional[str] = None
+
+    # together
+    together_api_key: Optional[str] = None
+
+    # vLLM
+    vllm_api_base: Optional[str] = None
+
+    # openllm
+    openllm_auth_type: Optional[str] = None
+    openllm_api_key: Optional[str] = None
+
+    # disable openapi schema generation
+    disable_schema_generation: bool = False
+
+
+cors_origins = [
+    "http://mirix.localhost",
+    "http://localhost:8283",
+    "http://localhost:8083",
+    "http://localhost:3000",
+    "http://localhost:4200",
+]
+
+# read pg_uri from ~/.mirix/pg_uri or set to none, this is to support Mirix Desktop
+default_pg_uri = None
+
+## check if --use-file-pg-uri is passed
+if "--use-file-pg-uri" in sys.argv:
+    try:
+        with open(Path.home() / ".mirix/pg_uri", "r") as f:
+            default_pg_uri = f.read()
+            # Note: Using print instead of logger to avoid circular import with mirix.log
+            print("Read pg_uri from ~/.mirix/pg_uri")
+    except FileNotFoundError:
+        pass
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="mirix_", extra="ignore")
+
+    mirix_dir: Optional[Path] = Field(Path.home() / ".mirix", env="MIRIX_DIR")
+    # Directory where uploaded/processed images are stored
+    # Can be overridden with MIRIX_IMAGES_DIR environment variable
+    images_dir: Optional[Path] = Field(
+        Path.home() / ".mirix" / "images", env="MIRIX_IMAGES_DIR"
+    )
+    debug: Optional[bool] = False
+    cors_origins: Optional[list] = cors_origins
+
+    # database configuration
+    pg_db: Optional[str] = None
+    pg_user: Optional[str] = None
+    pg_password: Optional[str] = None
+    pg_host: Optional[str] = None
+    pg_port: Optional[int] = None
+    pg_uri: Optional[str] = Field(
+        default_pg_uri, env="MIRIX_PG_URI"
+    )  # option to specify full uri
+    pg_pool_size: int = 80  # Concurrent connections
+    pg_max_overflow: int = 30  # Overflow limit
+    pg_pool_timeout: int = 30  # Seconds to wait for a connection
+    pg_pool_recycle: int = 1800  # When to recycle connections
+    pg_echo: bool = False  # Logging
+
+    # Redis configuration (optional - for caching and search acceleration)
+    redis_enabled: bool = Field(False, env="MIRIX_REDIS_ENABLED")  # Master switch
+    redis_host: Optional[str] = Field(None, env="MIRIX_REDIS_HOST")
+    redis_port: int = Field(6379, env="MIRIX_REDIS_PORT")
+    redis_db: int = Field(0, env="MIRIX_REDIS_DB")
+    redis_password: Optional[str] = Field(None, env="MIRIX_REDIS_PASSWORD")
+    redis_uri: Optional[str] = Field(None, env="MIRIX_REDIS_URI")  # Full URI override
+    
+    # Redis connection pool settings (optimized for production)
+    redis_max_connections: int = Field(50, env="MIRIX_REDIS_MAX_CONNECTIONS")  # Per container
+    redis_socket_timeout: int = Field(5, env="MIRIX_REDIS_SOCKET_TIMEOUT")  # Read/write timeout (seconds)
+    redis_socket_connect_timeout: int = Field(5, env="MIRIX_REDIS_SOCKET_CONNECT_TIMEOUT")  # Connect timeout (seconds)
+    redis_socket_keepalive: bool = Field(True, env="MIRIX_REDIS_SOCKET_KEEPALIVE")  # Enable TCP keepalive
+    redis_retry_on_timeout: bool = Field(True, env="MIRIX_REDIS_RETRY_ON_TIMEOUT")  # Retry on timeout errors
+    
+    # Redis TTL settings (cache expiration times in seconds)
+    redis_ttl_default: int = Field(3600, env="MIRIX_REDIS_TTL_DEFAULT")  # 1 hour default TTL
+    redis_ttl_blocks: int = Field(7200, env="MIRIX_REDIS_TTL_BLOCKS")  # 2 hours for hot data (blocks)
+    redis_ttl_messages: int = Field(7200, env="MIRIX_REDIS_TTL_MESSAGES")  # 2 hours for messages
+    redis_ttl_organizations: int = Field(43200, env="MIRIX_REDIS_TTL_ORGANIZATIONS")  # 12 hours for organizations
+    redis_ttl_users: int = Field(43200, env="MIRIX_REDIS_TTL_USERS")  # 12 hours for users
+    redis_ttl_agents: int = Field(43200, env="MIRIX_REDIS_TTL_AGENTS")  # 12 hours for agents
+    redis_ttl_tools: int = Field(43200, env="MIRIX_REDIS_TTL_TOOLS")  # 12 hours for tools
+
+    @property
+    def mirix_redis_uri(self) -> Optional[str]:
+        """Construct Redis URI from components or return explicit URI."""
+        if not self.redis_enabled:
+            return None
+        
+        if self.redis_uri:
+            return self.redis_uri
+        elif self.redis_host:
+            auth = f":{self.redis_password}@" if self.redis_password else ""
+            return f"redis://{auth}{self.redis_host}:{self.redis_port}/{self.redis_db}"
+        else:
+            return None
+
+    # multi agent settings
+    multi_agent_send_message_max_retries: int = 3
+    multi_agent_send_message_timeout: int = 20 * 60
+    multi_agent_concurrent_sends: int = 50
+
+    # telemetry logging
+    verbose_telemetry_logging: bool = False
+    otel_exporter_otlp_endpoint: Optional[str] = (
+        None  # otel default: "http://localhost:4317"
+    )
+    disable_tracing: bool = False
+
+    # uvicorn settings
+    uvicorn_workers: int = 1
+    uvicorn_reload: bool = False
+    uvicorn_timeout_keep_alive: int = 5
+
+    # event loop parallelism
+    event_loop_threadpool_max_workers: int = 43
+
+    # experimental toggle
+    use_experimental: bool = False
+
+    # logging configuration
+    log_level: str = Field("INFO", env="MIRIX_LOG_LEVEL")
+    log_file: Optional[Path] = Field(None, env="MIRIX_LOG_FILE")  # If set, enables file logging
+    log_to_console: bool = Field(True, env="MIRIX_LOG_TO_CONSOLE")  # Console logging is default
+    log_max_bytes: int = Field(10 * 1024 * 1024, env="MIRIX_LOG_MAX_BYTES")  # 10 MB
+    log_backup_count: int = Field(5, env="MIRIX_LOG_BACKUP_COUNT")
+
+    # LLM provider client settings
+    httpx_max_retries: int = 5
+    httpx_timeout_connect: float = 10.0
+    httpx_timeout_read: float = 60.0
+    httpx_timeout_write: float = 30.0
+    httpx_timeout_pool: float = 10.0
+    httpx_max_connections: int = 500
+    httpx_max_keepalive_connections: int = 500
+    httpx_keepalive_expiry: float = 120.0
+
+    # cron job parameters
+    enable_batch_job_polling: bool = False
+    poll_running_llm_batches_interval_seconds: int = 5 * 60
+
+    @property
+    def mirix_pg_uri(self) -> str:
+        if self.pg_uri:
+            return self.pg_uri
+        elif (
+            self.pg_db
+            and self.pg_user
+            and self.pg_password
+            and self.pg_host
+            and self.pg_port
+        ):
+            return f"postgresql+pg8000://{self.pg_user}:{self.pg_password}@{self.pg_host}:{self.pg_port}/{self.pg_db}"
+        else:
+            return "postgresql+pg8000://mirix:mirix@localhost:5432/mirix"
+
+    # add this property to avoid being returned the default
+    # reference: https://github.com/mirix-ai/mirix/issues/1362
+    @property
+    def mirix_pg_uri_no_default(self) -> str:
+        if self.pg_uri:
+            return self.pg_uri
+        elif (
+            self.pg_db
+            and self.pg_user
+            and self.pg_password
+            and self.pg_host
+            and self.pg_port
+        ):
+            return f"postgresql+pg8000://{self.pg_user}:{self.pg_password}@{self.pg_host}:{self.pg_port}/{self.pg_db}"
+        else:
+            return None
+
+
+class TestSettings(Settings):
+    model_config = SettingsConfigDict(env_prefix="mirix_test_", extra="ignore")
+
+    mirix_dir: Optional[Path] = Field(Path.home() / ".mirix/test", env="MIRIX_TEST_DIR")
+    images_dir: Optional[Path] = Field(
+        Path.home() / ".mirix/test" / "images", env="MIRIX_TEST_IMAGES_DIR"
+    )
+
+
+# singleton
+settings = Settings(_env_parse_none_str="None")
+test_settings = TestSettings()
+model_settings = ModelSettings()
+tool_settings = ToolSettings()
+summarizer_settings = SummarizerSettings()

mirix/system.py

@@ -0,0 +1,261 @@
+import json
+import uuid
+import warnings
+from typing import Optional
+
+from .constants import (
+    INITIAL_BOOT_MESSAGE,
+    INITIAL_BOOT_MESSAGE_SEND_MESSAGE_FIRST_MSG,
+    INITIAL_BOOT_MESSAGE_SEND_MESSAGE_THOUGHT,
+    MESSAGE_SUMMARY_WARNING_STR,
+)
+from .helpers.datetime_helpers import get_local_time
+from .helpers.json_helpers import json_dumps
+
+
+def get_initial_boot_messages(version="startup"):
+    if version == "startup":
+        initial_boot_message = INITIAL_BOOT_MESSAGE
+        messages = [
+            {"role": "assistant", "content": initial_boot_message},
+        ]
+
+    elif version == "startup_with_send_message":
+        tool_call_id = str(uuid.uuid4())
+        messages = [
+            # first message includes both inner monologue and function call to send_message
+            {
+                "role": "assistant",
+                "content": INITIAL_BOOT_MESSAGE_SEND_MESSAGE_THOUGHT,
+                # "function_call": {
+                #     "name": "send_message",
+                #     "arguments": '{\n  "message": "' + f"{INITIAL_BOOT_MESSAGE_SEND_MESSAGE_FIRST_MSG}" + '"\n}',
+                # },
+                "tool_calls": [
+                    {
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": "send_message",
+                            "arguments": '{\n  "message": "'
+                            + f"{INITIAL_BOOT_MESSAGE_SEND_MESSAGE_FIRST_MSG}"
+                            + '"\n}',
+                        },
+                    }
+                ],
+            },
+            # obligatory function return message
+            {
+                # "role": "function",
+                "role": "tool",
+                "name": "send_message",  # NOTE: technically not up to spec, this is old functions style
+                "content": package_function_response(True, None),
+                "tool_call_id": tool_call_id,
+            },
+        ]
+
+    elif version == "startup_with_send_message_gpt35":
+        tool_call_id = str(uuid.uuid4())
+        messages = [
+            # first message includes both inner monologue and function call to send_message
+            {
+                "role": "assistant",
+                "content": "*inner thoughts* Still waiting on the user. Sending a message with function.",
+                # "function_call": {"name": "send_message", "arguments": '{\n  "message": "' + f"Hi, is anyone there?" + '"\n}'},
+                "tool_calls": [
+                    {
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": "send_message",
+                            "arguments": '{\n  "message": "'
+                            + "Hi, is anyone there?"
+                            + '"\n}',
+                        },
+                    }
+                ],
+            },
+            # obligatory function return message
+            {
+                # "role": "function",
+                "role": "tool",
+                "name": "send_message",
+                "content": package_function_response(True, None),
+                "tool_call_id": tool_call_id,
+            },
+        ]
+
+    else:
+        raise ValueError(version)
+
+    return messages
+
+
+def get_contine_chaining(
+    reason="Automated timer",
+    include_location=False,
+    location_name="San Francisco, CA, USA",
+):
+    # Package the message with time and location
+    formatted_time = get_local_time()
+    packaged_message = {
+        "type": "contine_chaining",
+        "reason": reason,
+        "time": formatted_time,
+    }
+
+    if include_location:
+        packaged_message["location"] = location_name
+
+    return json_dumps(packaged_message)
+
+
+def get_login_event(
+    last_login="Never (first login)",
+    include_location=False,
+    location_name="San Francisco, CA, USA",
+):
+    # Package the message with time and location
+    formatted_time = get_local_time()
+    packaged_message = {
+        "type": "login",
+        "last_login": last_login,
+        "time": formatted_time,
+    }
+
+    if include_location:
+        packaged_message["location"] = location_name
+
+    return json_dumps(packaged_message)
+
+
+def package_user_message(
+    user_message: str,
+    time: Optional[str] = None,
+    include_location: bool = False,
+    location_name: Optional[str] = "San Francisco, CA, USA",
+    name: Optional[str] = None,
+):
+    # Package the message with time and location
+    formatted_time = time if time else get_local_time()
+    packaged_message = {
+        "type": "user_message",
+        "message": user_message,
+        "time": formatted_time,
+    }
+
+    if include_location:
+        packaged_message["location"] = location_name
+
+    if name:
+        packaged_message["name"] = name
+
+    return json_dumps(packaged_message)
+
+
+def package_function_response(was_success, response_string, timestamp=None):
+    formatted_time = get_local_time() if timestamp is None else timestamp
+    packaged_message = {
+        "status": "OK" if was_success else "Failed",
+        "message": response_string,
+        "time": formatted_time,
+    }
+
+    return json_dumps(packaged_message)
+
+
+def package_system_message(system_message, message_type="system_alert", time=None):
+    formatted_time = time if time else get_local_time()
+    packaged_message = {
+        "type": message_type,
+        "message": system_message,
+        "time": formatted_time,
+    }
+
+    return json.dumps(packaged_message)
+
+
+def package_summarize_message(
+    summary,
+    summary_message_count,
+    hidden_message_count,
+    total_message_count,
+    timestamp=None,
+):
+    context_message = (
+        f"Note: prior messages ({hidden_message_count} of {total_message_count} total messages) have been hidden from view due to conversation memory constraints.\n"
+        + f"The following is a summary of the previous {summary_message_count} messages:\n {summary}"
+    )
+
+    formatted_time = get_local_time() if timestamp is None else timestamp
+    packaged_message = {
+        "type": "system_alert",
+        "message": context_message,
+        "time": formatted_time,
+    }
+
+    return json_dumps(packaged_message)
+
+
+def package_summarize_message_no_summary(
+    hidden_message_count, timestamp=None, message=None
+):
+    """Add useful metadata to the summary message"""
+
+    # Package the message with time and location
+    formatted_time = get_local_time() if timestamp is None else timestamp
+    context_message = (
+        message
+        if message
+        else f"Note: {hidden_message_count} prior messages with the user have been hidden from view due to conversation memory constraints. Older messages are stored in Recall Memory and can be viewed using functions."
+    )
+    packaged_message = {
+        "type": "system_alert",
+        "message": context_message,
+        "time": formatted_time,
+    }
+
+    return json_dumps(packaged_message)
+
+
+def get_token_limit_warning():
+    formatted_time = get_local_time()
+    packaged_message = {
+        "type": "system_alert",
+        "message": MESSAGE_SUMMARY_WARNING_STR,
+        "time": formatted_time,
+    }
+
+    return json_dumps(packaged_message)
+
+
+def unpack_message(packed_message) -> str:
+    """Take a packed message string and attempt to extract the inner message content"""
+
+    try:
+        message_json = json.loads(packed_message)
+    except (ValueError, TypeError):
+        warnings.warn(
+            f"Was unable to load message as JSON to unpack: '{packed_message}'"
+        )
+        return packed_message
+
+    if "message" not in message_json:
+        if "type" in message_json and message_json["type"] in [
+            "login",
+            "contine_chaining",
+        ]:
+            # This is a valid user message that the ADE expects, so don't print warning
+            return packed_message
+        warnings.warn(
+            f"Was unable to find 'message' field in packed message object: '{packed_message}'"
+        )
+        return packed_message
+    else:
+        message_type = message_json["type"]
+        if message_type != "user_message":
+            warnings.warn(
+                f"Expected type to be 'user_message', but was '{message_type}', so not unpacking: '{packed_message}'"
+            )
+            return packed_message
+        return message_json.get("message")

jl_ecms_client-0.2.7.dist-info/RECORD

@@ -1,53 +0,0 @@
-jl_ecms_client-0.2.7.dist-info/licenses/LICENSE,sha256=8fOrt8t-9Lb_RKUa_xmj1_bVzbbluGEXERWSfM7rXfY,10758
-mirix/client/__init__.py,sha256=QOjO6HJdl5CBK9QrSvAILmlCWfoobt8CNBnRWsoZFBs,2383
-mirix/client/client.py,sha256=9RK7BP5Fjonn5wKfUK5WK2fZS5--1mtdbmO50gQmdNs,88727
-mirix/client/constants.py,sha256=6NVFu3yZqm1HW6vKA1HCpNc8l-ds6yGPyUGf-tqXJ78,2011
-mirix/client/remote_client.py,sha256=P0sTbGlqeuT_cIvGh243NK1Uf4a2JgNkQLdLvN950HQ,42646
-mirix/client/utils.py,sha256=xPAvR3slBQ5srOFLtYTqpL3PeD5n0YsxBRR1sLgKBdY,786
-mirix/helpers/__init__.py,sha256=2QXDAywb0wF3JNLC7GgMDJb_kQpwvlb6ZCnjuLmOfPw,78
-mirix/helpers/converters.py,sha256=WuYkra4c9-JRC2lRo7LmmFMH42qf3k6ox3OGOYlDQLk,13504
-mirix/helpers/datetime_helpers.py,sha256=7U5ZJkE0cLki4sG8ukIHZSAoFfQpLWQu2kFekETy6Zg,2633
-mirix/helpers/json_helpers.py,sha256=2iq1Lyxa8Ofes38QHAOBZHE7I2jS65h-zkAXWJzpm3k,1222
-mirix/helpers/message_helpers.py,sha256=xOn2Uwx5XK4C1ahYKmFe9ak7QjE5vcPVuZBcLDYxkZA,2571
-mirix/helpers/tool_rule_solver.py,sha256=LM9YuugmYtxxtcrD7GakbCNvmnuLK4Zp5KV8vA-UNSA,6542
-mirix/schemas/__init__.py,sha256=HPrtil4I9_KC2u6eJZpBJ2dbl_YxOj_ZeYnKYq3RSGM,24
-mirix/schemas/agent.py,sha256=SYiLURW1PYAHSXAaBOx8N8kaP_5Qt7ujWVxf2uA4BDM,15854
-mirix/schemas/block.py,sha256=NhqaSCOHKACHb77F77NhET-Sy8bZqSJJnenQaC7pBR4,5145
-mirix/schemas/cloud_file_mapping.py,sha256=i_5N41hNt0rEl-fvnGoPggLMbFdEk97wI71qQTjHKIg,977
-mirix/schemas/embedding_config.py,sha256=aHySSdkn5BeL_i6UQLuyDmjo40FCWvKW1Yfc01hQYak,4050
-mirix/schemas/enums.py,sha256=7Z4Wotyndp_eghhIvSdjFA3nMp_Vh_pcK1A_MrkBFRA,1357
-mirix/schemas/environment_variables.py,sha256=mSL5U2NYxJHO4fb2dF3YgPyINgYgelsSzMqQ6nsjzng,2573
-mirix/schemas/episodic_memory.py,sha256=KXr1hHXEqceF5wjMDpAN6MMkRthY-GBnFUcW_QDYUTg,6330
-mirix/schemas/file.py,sha256=J92aWus84jPoF71wRtKIvoAPSdIDt4McEM6yDWzHiqg,2064
-mirix/schemas/health.py,sha256=zT6mYovvD17iJRuu2rcaQQzbEEYrkwvAE9TB7iU824c,139
-mirix/schemas/knowledge_vault.py,sha256=i9qOXp7D8tOgjpRlThDIBDBB4TvOtO7fpSCgaLZW3Lg,6316
-mirix/schemas/llm_config.py,sha256=ZTJtqlD-J8wsEx4_aAMbqHaL0vxDrDjsgwD5RK07zcs,7256
-mirix/schemas/memory.py,sha256=ORWX_qxQBirsHN9vTlr3d_UYLiUB9tlP8DnIh_obIfA,11991
-mirix/schemas/message.py,sha256=_alOnt4BjdBw92Etg_i4vUhcWwdvD-54r5yuuydPBkc,53990
-mirix/schemas/mirix_base.py,sha256=DMkOMZw1mw8Vte8yCGK9xAhqgY2O2CO6uYD9pgf9e6A,3859
-mirix/schemas/mirix_message.py,sha256=WQHdA1dhLiwh0I3y710JMZx42fFmFkXBKdQdl1XdiDY,15334
-mirix/schemas/mirix_message_content.py,sha256=xdgTM5AkkONe4mjgcZNuKkbKk_fEY4rqzobD7cvy5cA,6815
-mirix/schemas/mirix_request.py,sha256=A2CwbKaIQcc1KchT0U3Ro82mBe6RerpDPFguDN_JFCo,1399
-mirix/schemas/mirix_response.py,sha256=w_hTYJs_cpBdx1mWfezzbiV49U4MWHKEfwFrYSMAVR0,7444
-mirix/schemas/organization.py,sha256=tHjE4CmboPJV8OMZ1BfGuFanMJKCED5rh1IBpNQhGTc,1120
-mirix/schemas/procedural_memory.py,sha256=XdX0tfX3LLRXngEP7c3Y2A6KEx7b9dY_ADKOrCdSqQg,5509
-mirix/schemas/providers.py,sha256=PNXCRGw2UqAwNgk3y2xqXa9bbH9ySVInLeU8qftTca4,30552
-mirix/schemas/resource_memory.py,sha256=0w6tRynshimSviPd7fkXG77KqCxEBeuHsnjpYXILTVQ,4907
-mirix/schemas/sandbox_config.py,sha256=X89bm-6QCE7n-ugQ7GyNfan6ZxKXU1UOwdWP0_PXnc4,4460
-mirix/schemas/semantic_memory.py,sha256=vpDs9X1h6BRaAWnGkF0Il6oiYqosbmxahFh1OFb8WA0,5993
-mirix/schemas/source.py,sha256=9Qe-E15sDXcopd3UPW0-sC3lFHIjlV44t_lV7KxkCWY,3050
-mirix/schemas/step.py,sha256=msWn5uBdaR3dYmjTuCwmvq3Mm-kP0Ha8e3-2sfCvG1Y,1826
-mirix/schemas/tool.py,sha256=ypkDYr8dikfyUU7tgnEF-CCam97TYYbTtaJ3K6PTebg,10487
-mirix/schemas/tool_rule.py,sha256=uwyrOX38Vtp-6V1CbHnvBI3DzmWpW2zy7UPtYPmewus,6877
-mirix/schemas/usage.py,sha256=QX7uIaK7-GgrZDMgeot-1ae2n-ol0yif3E7JsLF0Sxk,1166
-mirix/schemas/user.py,sha256=9ywAkPX__q3Ja4lfs-YIiCKQkFmE3-poIimt0owGz_E,2476
-mirix/schemas/openai/__init__.py,sha256=u3PhqJOMwv1fPfMOD6TNZ6zsWvEBpmur4Ypwj733UB0,24
-mirix/schemas/openai/chat_completion_request.py,sha256=eC4fMMJRucHtXfCUVPZu7ZeSt_LUPAsZtu_Z-hzfW6c,3395
-mirix/schemas/openai/chat_completion_response.py,sha256=1hF0Gaxvd03oBdKupz37qk_2LVFoev0T8GVEHHyVLfo,4054
-mirix/schemas/openai/chat_completions.py,sha256=PfC4MOiADLW_BfgmUohqK033VB4IO5fLIR1416C1DCE,3616
-mirix/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNosmLVSuhXYa_xU,357
-mirix/schemas/openai/openai.py,sha256=gXfYwdGRJ-co15zVKw3lua0iZL_lJBBo03XMWsw1uTI,8394
-jl_ecms_client-0.2.7.dist-info/METADATA,sha256=T7mM1EjJebIwmHGR_8Ma5ln6dKEUfaY1fRsGOUPFO2Q,10843
-jl_ecms_client-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jl_ecms_client-0.2.7.dist-info/top_level.txt,sha256=hQ_Eh5KYzEGkhtEyWHdBYJ5iCom6_nlj0zQ6-v0WDIY,6
-jl_ecms_client-0.2.7.dist-info/RECORD,,

mirix/client/constants.py

@@ -1,60 +0,0 @@
-"""
-Client-side constants - minimal set needed by schemas and client code.
-
-These are the constants required by the client package (schemas, helpers, client).
-The full server constants module (mirix.constants) imports from here and adds
-additional server-only constants.
-"""
-
-# Embedding constants
-MAX_EMBEDDING_DIM = 4096  # maximum supported embedding size - do NOT change or else DBs will need to be reset
-DEFAULT_EMBEDDING_CHUNK_SIZE = 300
-MIN_CONTEXT_WINDOW = 4096
-
-# Memory limits
-CORE_MEMORY_BLOCK_CHAR_LIMIT: int = 5000
-
-# Function/Tool constants
-FUNCTION_RETURN_CHAR_LIMIT = 60000  # ~300 words
-TOOL_CALL_ID_MAX_LEN = 29
-
-# Tool module names
-COMPOSIO_TOOL_TAG_NAME = "composio"
-MIRIX_CORE_TOOL_MODULE_NAME = "mirix.functions.function_sets.base"
-MIRIX_MEMORY_TOOL_MODULE_NAME = "mirix.functions.function_sets.memory_tools"
-MIRIX_EXTRA_TOOL_MODULE_NAME = "mirix.functions.function_sets.extras"
-
-# Message defaults
-DEFAULT_MESSAGE_TOOL = "send_message"
-DEFAULT_MESSAGE_TOOL_KWARG = "message"
-
-# LLM model token limits
-LLM_MAX_TOKENS = {
-    "DEFAULT": 8192,
-    ## OpenAI models: https://platform.openai.com/docs/models/overview
-    "chatgpt-4o-latest": 128000,
-    "gpt-4o-2024-08-06": 128000,
-    "gpt-4-turbo-preview": 128000,
-    "gpt-4o": 128000,
-    "gpt-3.5-turbo-instruct": 16385,
-    "gpt-4-0125-preview": 128000,
-    "gpt-3.5-turbo-0125": 16385,
-    "gpt-4-turbo-2024-04-09": 128000,
-    "gpt-4-turbo": 8192,
-    "gpt-4o-2024-05-13": 128000,
-    "gpt-4o-mini": 128000,
-    "gpt-4o-mini-2024-07-18": 128000,
-    "gpt-4-1106-preview": 128000,
-    "gpt-4": 8192,
-    "gpt-4-32k": 32768,
-    "gpt-4-0613": 8192,
-    "gpt-4-32k-0613": 32768,
-    "gpt-4-0314": 8192,  # legacy
-    "gpt-4-32k-0314": 32768,  # legacy
-    "gpt-3.5-turbo-1106": 16385,
-    "gpt-3.5-turbo": 4096,
-    "gpt-3.5-turbo-16k": 16385,
-    "gpt-3.5-turbo-0613": 4096,  # legacy
-    "gpt-3.5-turbo-16k-0613": 16385,  # legacy
-    "gpt-3.5-turbo-0301": 4096,  # legacy
-}