persona-models 0.1.0__tar.gz

persona_models-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+dist/
+*.egg-info/
+.eggs/

persona_models-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: persona-models
+Version: 0.1.0
+Summary: Shared Pydantic models for Persona AI platform
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0.0

persona_models-0.1.0/persona_models/__init__.py

@@ -0,0 +1,22 @@
+from persona_models.common import create_uuid, create_shortuuid, Paginated
+from persona_models.agents import AgentConfiguration, ModelConfiguration, SynthesizerConfiguration
+from persona_models.sessions import (
+    Session, Message, FunctionCall, FunctionResponse, File, Image,
+    AgentContext, AgentResponse, GenerationResponse, TransferAction,
+    CollaborationMode, EmptyMessage, MessageAccumulator, merge_messages,
+    Source, SourceChunk, Reasoning,
+)
+from persona_models.workflows import Workflow, Connection, WorkflowResult
+from persona_models.triggers import Trigger, TriggerSource, TriggerDestination, TriggerExecutionResult
+from persona_models.credentials import Credentials, AuthorizeRequest
+from persona_models.knowledge_bases import KnowledgeBase, KnowledgeBaseDocument
+from persona_models.projects import Project
+from persona_models.features import FeatureTemplate, Feature, McpServerConfiguration, FlagConfiguration
+from persona_models.missions import Mission, MissionStep, WorkerAgent
+from persona_models.service_prices import ServicePrice, Usage, UsageCost
+from persona_models.mcp import (
+    HttpTransport, StdioTransport, McpTransport,
+    ToolInvokeRequest, ToolInvokeResponse,
+    RetrieveResourceRequest, RetrieveResourceResponse,
+    GenerationRequest,
+)

persona_models-0.1.0/persona_models/agents.py

@@ -0,0 +1,304 @@
+from typing import List, Optional, Literal, Union
+
+from pydantic import BaseModel, Field, ConfigDict
+from pydantic.alias_generators import to_camel
+from typing_extensions import TypedDict
+
+from persona_models.common import create_uuid
+
+SynthesizerType = Literal["gcloud", "elevenlabs", "gtts", "openai"]
+
+LanguageCode = Literal["en-US", "it-IT", "es-ES", "fr-FR", "de-DE", "pt-BR"]
+
+
+class SynthesizerConfiguration(BaseModel):
+    enabled: Optional[bool] = True
+    synthesizer_name: SynthesizerType = "gcloud"
+    language_code: Optional[LanguageCode] = None
+    voice: Optional[str] = None
+    sample_rate_hertz: Optional[int] = 24000
+    speed: Optional[float] = None
+    similarity_boost: Optional[float] = None
+    stability: Optional[float] = None
+    style: Optional[float] = None
+    voice_instructions: Optional[str] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+TranscriberType = Literal["gcloud", "deepgram"]
+
+
+class TranscriberConfiguration(BaseModel):
+    enabled: Optional[bool] = True
+    transcriber_name: TranscriberType = "gcloud"
+    language_code: Optional[LanguageCode] = None
+    sample_rate_hertz: Optional[int] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+ModelName = Literal[
+    # Google
+    "gemini-3-pro",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-2.0-flash",
+    "gemini-1.5-pro",
+    "gemini-1.5-flash",
+    "gemini-2.0-flash-001",
+    "gemini-2.0-flash-lite",
+    "gemini-2.0-flash-lite-001",
+    "gemini-1.5-flash-latest",
+    "gemini-1.5-flash-001",
+    "gemini-1.5-flash-002",
+    "gemini-1.5-pro-latest",
+    "gemini-1.5-pro-001",
+    "gemini-1.5-pro-002",
+    # OpenAI
+    "gpt-5.2",
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4.5",
+    "o1",
+    "o1-mini",
+    "o3-mini",
+    "o4-mini",
+    "o4-mini-high",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    # Fireworks
+    "accounts/fireworks/models/minimax-m2p5",
+    "accounts/fireworks/models/deepseek-v3p2",
+    "accounts/fireworks/models/kimi-k2p5",
+    "accounts/fireworks/models/glm-5",
+    # Grok
+    "grok-4-1-fast-reasoning",
+    "grok-4-1-fast-non-reasoning",
+    "grok-code-fast-1",
+    "grok-4-fast-reasoning",
+    "grok-4-fast-non-reasoning",
+    "grok-4-0709",
+    "grok-3-mini",
+    "grok-3",
+    "grok-2-vision-1212",
+    # Ollama
+    "ollama",
+]
+
+
+class ModelConfiguration(BaseModel):
+    model_name: ModelName
+    temperature: float = 1
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]] = None
+    url: Optional[str] = None
+    ollama_model_name: Optional[str] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, use_enum_values=True
+    )
+
+
+ToolType = Literal["remote", "local"]
+
+
+class ToolRemoteConfig(BaseModel):
+    service_url: str
+    secret: Optional[str] = None
+    timeout: Optional[int] = 60
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class ToolProperty(TypedDict):
+    type: str
+    description: str
+
+
+class ToolParameters(TypedDict):
+    type: str
+    title: str
+    required: Optional[List[str]]
+    properties: Optional[dict[str, ToolProperty]]
+
+
+class ToolOutput(TypedDict):
+    type: str
+    title: str
+    properties: Optional[dict[str, ToolProperty]]
+
+
+class ToolLocalConfig(BaseModel):
+    parameters: ToolParameters
+    output: ToolOutput
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Tool(BaseModel):
+    type: ToolType = "remote"
+    name: str
+    description: Optional[str] = None
+    config: Union[ToolRemoteConfig, ToolLocalConfig]
+
+    def is_remote(self) -> bool:
+        return self.type == "remote"
+
+    def is_local(self) -> bool:
+        return self.type == "local"
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, use_enum_values=True
+    )
+
+
+class ToolkitConfiguration(BaseModel):
+    tools: List[Tool] | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+KnowledgeType = Literal["multi_hop", "simple"]
+
+
+class MultiHopKnowledgeConfiguration(BaseModel):
+    model: ModelConfiguration
+    max_steps: int
+
+
+class KnowledgeConfiguration(BaseModel):
+    enabled: Optional[bool] = True
+    knowledge_type: KnowledgeType = "multi_hop"
+    namespace: str | list[str] | None = None
+    number_of_entries: int = 3
+    knowledge_base_id: str | None = None
+    args: Union[MultiHopKnowledgeConfiguration, dict] = Field(
+        default_factory=dict, alias="args"
+    )
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class TwilioConfiguration(BaseModel):
+    phone_number: str
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class WakeupConfiguration(BaseModel):
+    enabled: Optional[bool] = False
+    wakeup_words: List[str] = None
+    sleep_words: Optional[List[str]] = None
+    sleep_in_each_request: bool = False
+    sleep_delay_seconds: Optional[int] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class TelegramConfiguration(BaseModel):
+    enabled: Optional[bool] = False
+    bot_token: str
+    enabled_users: List[str] | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class WhatsAppConfiguration(BaseModel):
+    phone_number_id: str
+    enabled_users: List[str] | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Variable(BaseModel):
+    name: str
+    value: str | None = None
+    description: str | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Collaborator(BaseModel):
+    agent_id: str
+    scope: str
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+CollaborationModeType = Literal[
+    "persistent_transfer", "delegate_and_return", "consult_then_respond"
+]
+
+
+class CollaborationConfiguration(BaseModel):
+    enabled: Optional[bool] = False
+    collaborators: List[Collaborator]
+    mode: CollaborationModeType = "delegate_and_return"
+    max_number_of_iterations: int = 10
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, use_enum_values=True
+    )
+
+
+AgentType = Literal["agent"]
+
+AgentProtocol = Literal["webrtc", "twilio", "rest", "websocket", "telegram"]
+
+StmType = Literal["simple", "summary"]
+
+
+class NetworkConfiguration(BaseModel):
+    allowed_websites: Optional[List[str]] = None
+    allowed_ips: Optional[List[str]] = None
+
+
+class StmConfiguration(BaseModel):
+    type: StmType
+    max_messages: int = 10
+    model: ModelConfiguration | None = None
+    max_number_of_words: int = 50
+    include_tool_calls: bool = False
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
+
+
+class AgentConfiguration(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    project_id: str | None = None
+    api_key: str | None = None
+    code: str | None = None
+    name: str
+    description: Optional[str] = None
+    type: AgentType = "agent"
+    synthesizer: Optional[SynthesizerConfiguration] = None
+    transcriber: Optional[TranscriberConfiguration] = None
+    model: ModelConfiguration
+    system_instructions: Optional[str] = None
+    toolkit: Optional[ToolkitConfiguration] = None
+    variables: Optional[List[Variable]] = None
+    enabled_protocols: List[AgentProtocol] | None = None
+    twilio: Optional[TwilioConfiguration] = None
+    language_code: Optional[LanguageCode] = None
+    initial_message: Optional[str] = None
+    knowledge: Optional[KnowledgeConfiguration] = None
+    wakeup: Optional[WakeupConfiguration] = None
+    telegram: Optional[TelegramConfiguration] = None
+    whatsapp: Optional[WhatsAppConfiguration] = None
+    collaboration: Optional[CollaborationConfiguration] = None
+    network: Optional[NetworkConfiguration] = None
+    features: Optional[list] = None
+    response_schema: Optional[dict] = None
+    short_term_memory: Optional[StmConfiguration] = None
+    verbose_errors: bool = False
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, use_enum_values=True
+    )

persona_models-0.1.0/persona_models/common.py

@@ -0,0 +1,31 @@
+import uuid
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+TEntity = TypeVar("TEntity", bound=BaseModel)
+
+
+def create_uuid(prefix: str = None) -> str:
+    if prefix:
+        return f"{prefix}_{uuid.uuid4().hex}"
+    else:
+        return uuid.uuid4().hex
+
+
+def create_shortuuid(prefix: str = None) -> str:
+    short = uuid.uuid4().hex[:22]
+    if prefix:
+        return f"{prefix}_{short}"
+    else:
+        return short
+
+
+class Paginated(BaseModel, Generic[TEntity]):
+    items: list[TEntity]
+    total: int
+    page: int
+    size: int
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)

persona_models-0.1.0/persona_models/credentials.py

@@ -0,0 +1,51 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from persona_models.common import create_uuid
+
+
+class AuthorizeRequest(BaseModel):
+    name: str
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    scope: Optional[str] = None
+    api_key: Optional[str] = None
+    api_secret: Optional[str] = None
+    token: Optional[str] = None
+    server: Optional[str] = None
+    port: Optional[int] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    use_ssl: Optional[bool] = None
+    success_url: Optional[str] = None
+
+    model_config = ConfigDict(
+        populate_by_name=True, alias_generator=to_camel, extra="allow"
+    )
+
+
+class Credentials(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    name: str | None = None
+    project_id: str | None = None
+    provider: str
+    obtained_at: datetime | None = None
+    valid_until: datetime | None = None
+    data: dict = Field(default_factory=dict)
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    api_key: Optional[str] = None
+    api_secret: Optional[str] = None
+    token: Optional[str] = None
+    active: bool = True
+    server: Optional[str] = None
+    port: Optional[int] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    use_ssl: Optional[bool] = None
+    success_url: Optional[str] = None
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)

persona_models-0.1.0/persona_models/features.py

@@ -0,0 +1,53 @@
+from typing import Literal, List, Union, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+from persona_models.common import create_uuid
+from persona_models.mcp import HttpTransport, StdioTransport
+
+
+class McpServerConfiguration(BaseModel):
+    name: str
+    transport: Union[HttpTransport, StdioTransport]
+    enabled_tools: List[str] | None = None
+    disabled_tools: List[str] | None = None
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
+
+
+class FlagConfiguration(BaseModel):
+    flag: str
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+FeatureType = Literal["mcp", "flag"]
+FeatureConfiguration = Union[McpServerConfiguration, FlagConfiguration]
+
+
+class FeatureCredentialsConfiguration(BaseModel):
+    require_credentials: bool = False
+    credentials_type: str | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class FeatureTemplate(BaseModel):
+    id: str = Field(default_factory=create_uuid, validate_default=False)
+    project_id: str | None = None
+    type: FeatureType
+    name: str
+    description: str
+    configuration: Optional[FeatureConfiguration] = None
+    credentials_configuration: Optional[FeatureCredentialsConfiguration] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Feature(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    template_id: str | None = None
+    credentials_id: str | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)

persona_models-0.1.0/persona_models/knowledge_bases.py

@@ -0,0 +1,48 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from persona_models.common import create_uuid
+
+KnowledgeBaseQuality = Literal["extremely_high", "very_high", "high", "medium", "low"]
+KnowledgeBaseDocumentStatus = Literal["pending", "processing", "completed", "failed"]
+KnowledgeBaseChunkSize = Literal["small", "medium", "large"]
+
+
+class KnowledgeBase(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    project_id: str | None = None
+    name: str
+    description: str | None = None
+    quality: KnowledgeBaseQuality = "medium"
+    chunk_size: KnowledgeBaseChunkSize = "medium"
+    embedding_model: str = "text-multilingual-embedding-002"
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
+
+
+class KnowledgeBaseDocument(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    knowledge_base_id: str
+    path: str
+    name: str
+    size: int | None = None
+    total_pages: int | None = None
+    content_type: str | None = None
+    status: KnowledgeBaseDocumentStatus = "pending"
+    progress: float = 0.0
+    extractor: str = "fitz"
+    error: str | None = None
+    metadata: dict = Field(default_factory=dict)
+    callback_url: str | None = None
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
+
+
+class SearchChunksRequest(BaseModel):
+    query: str
+    top_k: int = 5
+    threshold: Optional[float] = None
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)

persona_models-0.1.0/persona_models/mcp.py

@@ -0,0 +1,69 @@
+from typing import Union, Optional, List
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class HttpTransport(BaseModel):
+    url: str
+    enable_persona_auth: bool = True
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
+
+
+class StdioTransport(BaseModel):
+    command: str
+    args: list[str]
+    env: Optional[dict[str, str]] = None
+    cwd: Optional[str] = None
+
+
+McpTransport = Union[HttpTransport, StdioTransport]
+
+
+class ToolInvokeRequest(BaseModel):
+    mcp_server_name: str
+    transport: McpTransport
+    tool_name: str
+    args: dict
+    session_id: str
+    credentials_id: str | None = None
+    user_id: str | None = None
+    billing_disabled: bool = False
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class ToolInvokeResponse(BaseModel):
+    results: list = []
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class RetrieveResourceRequest(BaseModel):
+    mcp_server_name: str
+    transport: McpTransport
+    uri: str
+    session_id: str
+    credentials_id: str | None = None
+    user_id: str | None = None
+    billing_disabled: bool = False
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class RetrieveResourceResponse(BaseModel):
+    contents: list = []
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class GenerationRequest(BaseModel):
+    agent_id: str | None = None
+    user_message: str | dict | list = ""
+    initial_context: dict | None = None
+    response_schema: dict | None = None
+    parent_session_id: str | None = None
+    user_id: str | None = None
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)

persona_models-0.1.0/persona_models/missions.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+from persona_models.common import create_uuid
+
+MissionStatus = Literal[
+    "draft", "planned", "active", "review", "paused", "completed", "failed", "cancelled"
+]
+MissionStepStatus = Literal["pending", "in_progress", "completed", "failed", "skipped"]
+
+
+class WorkerAgent(BaseModel):
+    agent_id: str
+    scope: str
+    name: Optional[str] = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class MissionStep(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    name: str
+    description: str | None = None
+    status: MissionStepStatus = "pending"
+    worker_agent_id: str | None = None
+    parent_step_id: str | None = None
+    dependencies: List[str] = Field(default_factory=list)
+    output: str | None = None
+    error: str | None = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Mission(BaseModel):
+    id: str = Field(default_factory=create_uuid)
+    project_id: str
+    name: str
+    goal: str
+    status: MissionStatus = "draft"
+    planner_agent_id: str
+    worker_agents: List[WorkerAgent] = Field(default_factory=list)
+    steps: List[MissionStep] = Field(default_factory=list)
+    current_step_id: str | None = None
+    version: int = 1
+    user_instructions: List[str] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    def get_step(self, step_id: str) -> Optional[MissionStep]:
+        for step in self.steps:
+            if step.id == step_id or step.name == step_id:
+                return step
+        return None
+
+    def get_root_steps(self) -> List[MissionStep]:
+        return [s for s in self.steps if s.parent_step_id is None]
+
+    def get_ready_steps(self) -> List[MissionStep]:
+        completed_ids = {s.id for s in self.steps if s.status == "completed"}
+        return [
+            s
+            for s in self.steps
+            if s.status == "pending"
+            and all(dep in completed_ids for dep in s.dependencies)
+        ]
+
+
+class CreateMissionRequest(BaseModel):
+    name: str
+    goal: str
+    planner_agent_id: str
+    worker_agents: List[WorkerAgent] = Field(default_factory=list)
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)