pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/lab/models.py

@@ -1,3 +1,4 @@
+import re
 from typing import Literal, Optional, List, Dict, Any, Union, Iterator
 
 from pydantic import model_validator, Field, field_validator
@@ -14,7 +15,8 @@ class FilterSettings(CustomBaseModel):
     :param status: str - Status filter, defaults to None.
     :param start: int - Starting index for pagination, defaults to None.
     :param count: int - Number of items to return, defaults to None.
-    :param access_scope: str - Access scope filter, defaults to "public".
+    :param is_active: bool - If it's active. Defaults to false.
+    :param access_scope: str - Access scope filter, defaults to "private".
     :param allow_drafts: bool - Whether to include draft items, defaults to True.
     :param allow_external: bool - Whether to include external items, defaults to False.
     :param revision: str - Revision of the agent, defaults to 0.
@@ -26,9 +28,10 @@ class FilterSettings(CustomBaseModel):
     status: Optional[str] = Field(default=None, description="Status filter")
     start: Optional[int] = Field(default=None, description="Starting index for pagination")
     count: Optional[int] = Field(default=None, description="Number of items to return")
-    access_scope: Optional[str] = Field(default="public", alias="accessScope", description="Access scope filter")
+    access_scope: Optional[str] = Field(default="private", alias="accessScope", description="Access scope filter")
     allow_drafts: Optional[bool] = Field(default=True, alias="allowDrafts", description="Whether to include draft items")
     allow_external: Optional[bool] = Field(default=False, alias="allowExternal", description="Whether to include external items")
+    is_active: Optional[bool] = Field(default=False, alias="isActive", description="Whether it's active")
     revision: Optional[str] = Field(default=None, description="Revision of the agent")
     version: Optional[int] = Field(default=None, description="Version of the agent")
     scope: Optional[str] = Field(None, description="Filter by scope (e.g., 'builtin', 'external', 'api')")
@@ -68,15 +71,16 @@ class LlmConfig(CustomBaseModel):
     :param sampling: Sampling - Sampling configuration for the LLM.
     """
     max_tokens: int = Field(..., alias="maxTokens")
-    timeout: int = Field(..., alias="timeout")
+    timeout: Optional[int] = Field(60, alias="timeout")
     sampling: Optional[Sampling] = Field(Sampling(), alias="sampling")
 
     def to_dict(self):
-        return {
+        result = {
             "maxTokens": self.max_tokens,
             "timeout": self.timeout,
-            "sampling": self.sampling.to_dict()
+            "sampling": self.sampling.to_dict() if self.sampling else None
         }
+        return {k: v for k, v in result.items() if v is not None}
 
     def __str__(self):
         return str(self.to_dict())
@@ -90,7 +94,7 @@ class Model(CustomBaseModel):
     :param llm_config: Optional[LlmConfig] - Overrides default agent LLM settings.
     :param prompt: Optional[dict] - A tailored prompt specific to this model.
     """
-    name: str = Field(..., alias="name")
+    name: Optional[str] = Field(None, alias="name")
     llm_config: Optional[LlmConfig] = Field(None, alias="llmConfig")
     prompt: Optional[Dict[str, Any]] = Field(None, alias="prompt")
 
@@ -157,12 +161,22 @@ class Prompt(CustomBaseModel):
     :param context: Optional[str] - Background context for the agent # NOT IMPLEMENTED YET
     :param examples: List[PromptExample] - List of example input-output pairs.
     """
-    instructions: str = Field(..., alias="instructions")
-    inputs: List[str] = Field(..., alias="inputs")
-    outputs: List[PromptOutput] = Field(..., alias="outputs")
+    instructions: Optional[str] = Field(None, alias="instructions")
+    inputs: Optional[List[str]] = Field(None, alias="inputs")
+    outputs: Optional[List[PromptOutput]] = Field([], alias="outputs")
     context: Optional[str] = Field(None, alias="context", description="Background context for the agent")
     examples: Optional[List[PromptExample]] = Field(None, alias="examples")
 
+    '''
+    @field_validator("instructions")
+    @classmethod
+    def validate_instructions(cls, value: str) -> str:
+        if not value.strip():
+            raise ValueError("instructions cannot be blank")
+
+        return value
+    '''
+
     @field_validator("outputs", mode="before")
     @classmethod
     def normalize_outputs(cls, value):
@@ -371,19 +385,54 @@ class ResourcePoolList(CustomBaseModel):
         self.resource_pools.append(item)
 
 
+class Permission(CustomBaseModel):
+    """
+    Represents permission settings for an agent.
+
+    :param chat_sharing: Literal["none", "organization", "project"] - Chat sharing permission level.
+    :param external_execution: Literal["none", "organization", "project"] - External execution permission level.
+    """
+    chat_sharing: Optional[Literal["none", "organization", "project"]] = Field(None, alias="chatSharing", description="Chat sharing permission level")
+    external_execution: Optional[Literal["none", "organization", "project"]] = Field(None, alias="externalExecution", description="External execution permission level")
+
+    def to_dict(self):
+        """Convert Permission to dictionary with API aliases."""
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+
+class Property(CustomBaseModel):
+    """
+    Represents a property key-value pair with data type.
+
+    :param data_type: str - Data type of the property (e.g., "String", "Number", "Boolean").
+    :param key: str - Property key identifier.
+    :param value: str - Property value.
+    """
+    data_type: str = Field(..., alias="dataType", description="Data type of the property")
+    key: str = Field(..., alias="key", description="Property key identifier")
+    value: str = Field(..., alias="value", description="Property value")
+
+    def to_dict(self):
+        """Convert Property to dictionary with API aliases."""
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+
 class AgentData(CustomBaseModel):
     """
     Represents the detailed configuration data for an agent.
 
     :param prompt: dict - Prompt instructions, inputs, outputs, and examples for the agent.
     :param llm_config: dict - Configuration parameters for the LLM (e.g., max tokens, timeout, temperature).
+    :param strategy_name: str - Strategy name used for the agent (e.g., Dynamic Prompting, Chain of Thought, Question Refinement, etc)
     :param models: ModelList - List of models available for the agent.
     :param resource_pools: Optional[List[ResourcePool]] - List of resource pools organizing tools and helper agents.
     """
     prompt: Prompt = Field(..., alias="prompt")
     llm_config: LlmConfig = Field(..., alias="llmConfig")
-    models: Union[ModelList, List[Model]] = Field(..., alias="models")
+    strategy_name: Optional[str] = Field("Dynamic Prompting", alias="strategyName")
+    models: Optional[Union[ModelList, List[Model]]] = Field(None, alias="models")
     resource_pools: Optional[ResourcePoolList] = Field(None, alias="resourcePools", description="List of resource pools organizing tools and helper agents")
+    properties: Optional[List[Property]] = Field(None, alias="properties", description="List of agent properties")
 
     @field_validator("prompt", mode="before")
     @classmethod
@@ -402,6 +451,8 @@ class AgentData(CustomBaseModel):
     @field_validator("models", mode="before")
     @classmethod
     def normalize_models(cls, value):
+        if value is None:
+            return None
         if isinstance(value, ModelList):
             return value
         elif isinstance(value, list):
@@ -417,6 +468,13 @@ class AgentData(CustomBaseModel):
             return ResourcePoolList(resource_pools=[ResourcePool.model_validate(item) if isinstance(item, dict) else item for item in value])
         return value
 
+    @field_validator("properties", mode="before")
+    @classmethod
+    def normalize_properties(cls, value):
+        if isinstance(value, list):
+            return [Property.model_validate(item) if isinstance(item, dict) else item for item in value]
+        return value
+
     @model_validator(mode="after")
     def validate_resource_pools_unique_names(self):
         if self.resource_pools:
@@ -435,8 +493,10 @@ class AgentData(CustomBaseModel):
         result = {
             "prompt": self.prompt.to_dict(),
             "llmConfig": self.llm_config.to_dict(),
-            "models": self.models.to_dict(),
-            "resourcePools": [pool.to_dict() for pool in self.resource_pools] if self.resource_pools else None
+            "strategyName": self.strategy_name,
+            "models": self.models.to_dict() if self.models else None,
+            "resourcePools": [pool.to_dict() for pool in self.resource_pools] if self.resource_pools else None,
+            "properties": [prop.to_dict() for prop in self.properties] if self.properties else None
         }
         return {k: v for k, v in result.items() if v is not None}
 
@@ -473,7 +533,10 @@ class Agent(CustomBaseModel):
     is_draft: Optional[bool] = Field(True, alias="isDraft")
     is_readonly: Optional[bool] = Field(False, alias="isReadonly")
     revision: Optional[int] = Field(None, alias="revision")
-    version: Optional[int] = Field(None, alias="version")
+    version: Optional[Union[int | float]] = Field(None, alias="version")
+    sharing_scope: Optional[str] = Field(None, alias="sharingScope", description="Sharing scope of the agent")
+    permissions: Optional[Permission] = Field(None, alias="permissions", description="Permission settings")
+    effective_permissions: Optional[Permission] = Field(None, alias="effectivePermissions", description="Effective permission settings")
     agent_data: Optional[AgentData] = Field(None, alias="agentData")
 
     @field_validator("name")
@@ -512,6 +575,20 @@ class Agent(CustomBaseModel):
             return AgentData.model_validate(value)
         return value
 
+    @field_validator("permissions", mode="before")
+    @classmethod
+    def normalize_permissions(cls, value):
+        if isinstance(value, dict):
+            return Permission.model_validate(value)
+        return value
+
+    @field_validator("effective_permissions", mode="before")
+    @classmethod
+    def normalize_effective_permissions(cls, value):
+        if isinstance(value, dict):
+            return Permission.model_validate(value)
+        return value
+
     @model_validator(mode="after")
     def check_public_name(self):
         """
@@ -537,6 +614,9 @@ class Agent(CustomBaseModel):
             "isReadonly": self.is_readonly,
             "revision": self.revision,
             "version": self.version,
+            "sharingScope": self.sharing_scope,
+            "permissions": self.permissions.to_dict() if self.permissions else None,
+            "effectivePermissions": self.effective_permissions.to_dict() if self.effective_permissions else None,
             "agentData": self.agent_data.to_dict() if self.agent_data else None
         }
         return {k: v for k, v in result.items() if v is not None}
@@ -560,8 +640,8 @@ class AgentList(CustomBaseModel):
             return [Agent.model_validate(item) if isinstance(item, dict) else item for item in value]
         return value
 
-    def to_dict(self):
-        return [agent.to_dict() for agent in self.agents]
+    def to_list(self):
+        return [agent.to_dict() for agent in self.agents] if self.agents else []
 
     def __getitem__(self, index: int) -> Agent:
         if self.agents is None:
@@ -673,7 +753,7 @@ class Tool(CustomBaseModel):
     :param status: Optional[str] - Current status of the tool (e.g., "active"), defaults to None.
     """
     name: str = Field(..., alias="name", description="The name of the tool")
-    description: str = Field(..., alias="description", description="Description of the tool's purpose")
+    description: Optional[str] = Field(None, alias="description", description="Description of the tool's purpose")
     scope: str = Field("builtin", alias="scope", description="The scope of the tool (e.g., 'builtin', 'external', 'api')")
     parameters: Optional[List[ToolParameter]] = Field(None, alias="parameters", description="List of parameters required by the tool")
     access_scope: Optional[str] = Field(None, alias="accessScope", description="The access scope of the tool ('public' or 'private')")
@@ -695,6 +775,9 @@ class Tool(CustomBaseModel):
             raise ValueError("name cannot be blank")
         if ":" in value or "/" in value:
             raise ValueError("name cannot contain ':' or '/'")
+        # if not re.match(r'^[A-Za-z0-9_-]{1,64}$', value):
+        #    raise ValueError(
+        #        "name must contain only letters, numbers, underscores, or hyphens, and be 1-64 characters long")
         return value
 
     @field_validator("public_name")
@@ -713,6 +796,7 @@ class Tool(CustomBaseModel):
             raise ValueError("public_name is required if access_scope is 'public'")
         return self
 
+    '''
     @model_validator(mode="after")
     def validate_api_tool_requirements(self):
         if self.scope == "api" and not (self.open_api or self.open_api_json):
@@ -722,6 +806,7 @@ class Tool(CustomBaseModel):
             if len(param_keys) != len(set(param_keys)):
                 raise ValueError("All parameter keys must be unique within the tool")
         return self
+    '''
 
     @field_validator("parameters", mode="before")
     @classmethod
@@ -848,7 +933,7 @@ class ReasoningStrategy(CustomBaseModel):
             "systemPrompt": self.system_prompt,
             "accessScope": self.access_scope,
             "type": self.type,
-            "localizedDescriptions": [desc.to_dict() for desc in self.localized_descriptions],
+            "localizedDescriptions": [desc.to_dict() for desc in self.localized_descriptions] if isinstance(self.localized_descriptions, list) else None,
             "id": self.id
         }
         return {k: v for k, v in result.items() if v is not None}
@@ -897,6 +982,7 @@ class KnowledgeBase(CustomBaseModel):
     artifact_type_name: Optional[List[str]] = Field(None, alias="artifactTypeName", description="List of artifact type names")
     artifacts: Optional[List[str]] = Field(None, description="List of artifact identifiers")
     metadata: Optional[List[str]] = Field(None, description="List of metadata identifiers")
+    created_at: Optional[str] = Field(None, alias="createdAt", description="Timestamp when the knowledge base was created")
 
     @field_validator("artifacts")
     @classmethod
@@ -1248,6 +1334,7 @@ class Task(CustomBaseModel):
     :param artifact_types: Optional[List[dict]] - List of artifact types with 'name', 'description', 'isRequired', 'usageType', and 'artifactVariableKey'.
     :param is_draft: Optional[bool] - Whether the task is in draft mode.
     :param revision: Optional[int] - Revision number of the task.
+    :param version: Optional[int] - Version number of the task.
     :param status: Optional[str] - Current status of the task (e.g., 'active').
     """
     name: str = Field(..., description="Name of the task")
@@ -1258,6 +1345,7 @@ class Task(CustomBaseModel):
     artifact_types: Optional[Union[List[Dict[str, Any]], List[ArtifactType], ArtifactTypeList]] = Field(None, alias="artifactTypes", description="List of artifact types for the task")
     is_draft: Optional[bool] = Field(None, alias="isDraft", description="Whether the task is a draft")
     revision: Optional[int] = Field(None, description="Revision number of the task")
+    version: Optional[int] = Field(None, description="Version number of the task")
     status: Optional[str] = Field(None, description="Status of the task (e.g., 'active')")
 
     @field_validator("name")
@@ -1346,6 +1434,7 @@ class Task(CustomBaseModel):
             "artifactTypes": self.artifact_types.to_dict() if self.artifact_types else None,
             "isDraft": self.is_draft,
             "revision": self.revision,
+            "version": self.version,
             "status": self.status
         }
         return {k: v for k, v in result.items() if v is not None}
@@ -1548,7 +1637,7 @@ class Job(CustomBaseModel):
     """
     caption: str = Field(..., alias="caption", description="Description of the job's status and completion time")
     name: str = Field(..., alias="name", description="Name of the job")
-    parameters: List[JobParameter] = Field(..., alias="parameters", description="List of parameters for the job")
+    parameters: Optional[List[JobParameter]] = Field([], alias="parameters", description="List of parameters for the job")
     request: str = Field(..., alias="request", description="Timestamp when the job was requested")
     token: str = Field(..., alias="token", description="Unique token identifier for the job")
     topic: str = Field(..., alias="topic", description="Topic associated with the job")
@@ -1579,7 +1668,7 @@ class Job(CustomBaseModel):
         result = {
             "caption": self.caption,
             "name": self.name,
-            "parameters": [param.to_dict() for param in self.parameters] if self.parameters else None,
+            "parameters": [param.to_dict() for param in self.parameters] if self.parameters else [],
             "request": self.request,
             "token": self.token,
             "topic": self.topic,