kubiya-control-plane-api 0.9.15__py3-none-any.whl

control_plane_api/app/models/custom_integration.py

@@ -0,0 +1,99 @@
+"""
+Custom Integration Model
+
+Allows users to define custom integration instances with:
+- Environment variables
+- Secrets (references to secrets vault)
+- Files (content to be written to workspace)
+- Contextual prompt (guidance for the agent)
+"""
+from sqlalchemy import Column, String, DateTime, Text, JSON, Enum, Index, CheckConstraint, text, func
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+import enum
+
+from control_plane_api.app.database import Base
+
+
+class CustomIntegrationStatus(str, enum.Enum):
+    """Custom integration status"""
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    DELETED = "deleted"
+
+
+class CustomIntegration(Base):
+    """
+    Custom Integration Model
+
+    Allows users to define custom integrations that can be referenced
+    in execution environments, providing:
+    - Environment variables for credentials/config
+    - Secrets vault references
+    - Files to be written to workspace (e.g., config files, certificates)
+    - Contextual prompts to guide the agent
+    """
+    __tablename__ = "custom_integrations"
+
+    id = Column(UUID(as_uuid=False), primary_key=True, server_default=text("gen_random_uuid()"))
+    organization_id = Column(String(255), nullable=False, index=True)
+
+    # Identification
+    name = Column(String(255), nullable=False)  # e.g., "production-database"
+    integration_type = Column(String(100), nullable=False)  # e.g., "postgres", "mongodb", "redis", "custom"
+    description = Column(Text, nullable=True)
+
+    # Status
+    status = Column(Enum(CustomIntegrationStatus), nullable=False, server_default="active")
+
+    # Configuration
+    config = Column(JSONB, nullable=False, server_default=text("'{}'::jsonb"))
+    # Structure:
+    # {
+    #   "env_vars": {
+    #     "DB_HOST": "postgres.prod.example.com",
+    #     "DB_PORT": "5432",
+    #     "DB_NAME": "production"
+    #   },
+    #   "secrets": [
+    #     "DB_PASSWORD",      # Reference to secrets vault
+    #     "DB_SSL_CERT"       # Another secret reference
+    #   ],
+    #   "files": [
+    #     {
+    #       "path": "~/.postgresql/client.crt",
+    #       "content": "-----BEGIN CERTIFICATE-----...",
+    #       "mode": "0600",
+    #       "description": "PostgreSQL client certificate"
+    #     },
+    #     {
+    #       "path": "~/.postgresql/client.key",
+    #       "secret_ref": "POSTGRES_CLIENT_KEY",  # Load content from secret
+    #       "mode": "0600",
+    #       "description": "PostgreSQL client key"
+    #     }
+    #   ],
+    #   "context_prompt": "This is a PostgreSQL production database. Always use connection pooling. Max connections: 100.",
+    #   "connection_test": {
+    #     "enabled": true,
+    #     "command": "pg_isready -h $DB_HOST -p $DB_PORT",
+    #     "timeout": 5
+    #   }
+    # }
+
+    # Metadata
+    tags = Column(JSONB, nullable=True, server_default=text("'[]'::jsonb"))
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
+    created_by = Column(String(255), nullable=True)
+
+    # Constraints
+    __table_args__ = (
+        Index("idx_custom_integrations_org_name", "organization_id", "name", unique=True),
+        Index("idx_custom_integrations_org_type", "organization_id", "integration_type"),
+        Index("idx_custom_integrations_status", "status"),
+        CheckConstraint("name != ''", name="ck_custom_integration_name_not_empty"),
+        CheckConstraint("integration_type != ''", name="ck_custom_integration_type_not_empty"),
+    )
+
+    def __repr__(self):
+        return f"<CustomIntegration(id={self.id}, name={self.name}, type={self.integration_type})>"

control_plane_api/app/models/environment.py

@@ -0,0 +1,64 @@
+"""Environment model for execution environments"""
+from sqlalchemy import Column, String, DateTime, Text, ARRAY, ForeignKey, UniqueConstraint, Index, CheckConstraint, text
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+import enum
+
+from control_plane_api.app.database import Base
+
+
+class EnvironmentStatus(str, enum.Enum):
+    """Environment status"""
+    PENDING = "pending"
+    PROVISIONING = "provisioning"
+    READY = "ready"
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    ERROR = "error"
+    ARCHIVED = "archived"
+
+
+class Environment(Base):
+    """
+    Execution environment - represents a worker queue environment.
+    Maps to task queues in Temporal.
+    """
+
+    __tablename__ = "environments"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False, server_default=text("gen_random_uuid()"))
+    organization_id = Column(String(255), nullable=False)
+    name = Column(String(100), nullable=False)
+    display_name = Column(String(255), nullable=True)
+    description = Column(Text, nullable=True)
+    tags = Column(JSONB, nullable=True, server_default=text("'[]'::jsonb"))
+    settings = Column(JSONB, nullable=True, server_default=text("'{}'::jsonb"))
+    status = Column(String(50), nullable=True, server_default=text("'active'::character varying"))
+    created_at = Column(DateTime(timezone=True), nullable=True, server_default=text("now()"))
+    updated_at = Column(DateTime(timezone=True), nullable=True, server_default=text("now()"))
+    created_by = Column(String(255), nullable=True)
+    temporal_namespace_id = Column(UUID(as_uuid=True), nullable=True) # TODO add foreign key to temporal_namespaces table later or totally remove.
+    worker_token = Column(UUID(as_uuid=True), nullable=True, server_default=text("gen_random_uuid()"))
+    provisioning_workflow_id = Column(String(255), nullable=True)
+    error_message = Column(Text, nullable=True)
+    provisioned_at = Column(DateTime(timezone=True), nullable=True)
+    execution_environment = Column(JSONB, nullable=False, server_default=text("'{}'::jsonb"))
+    policy_ids = Column(ARRAY(String(255)), nullable=True, server_default=text("'{}'::character varying[]"))
+
+    __table_args__ = (
+        UniqueConstraint('organization_id', 'name', name='unique_queue_name_per_org'),
+        CheckConstraint(
+            "status::text = ANY (ARRAY['pending'::character varying, 'provisioning'::character varying, 'ready'::character varying, 'active'::character varying, 'inactive'::character varying, 'error'::character varying, 'archived'::character varying]::text[])",
+            name='task_queues_status_check'
+        ),
+        Index('idx_task_queues_namespace', 'temporal_namespace_id'),
+        Index('idx_task_queues_worker_token', 'worker_token'),
+        Index('idx_task_queues_org', 'organization_id'),
+        Index('idx_task_queues_status', 'organization_id', 'status', postgresql_where=text("status::text = 'active'::text")),
+        Index('idx_task_queues_name', 'organization_id', 'name'),
+        Index('idx_environments_execution_environment', 'execution_environment', postgresql_using='gin'),
+        Index('idx_environments_policy_ids', 'policy_ids', postgresql_using='gin'),
+    )
+
+    def __repr__(self):
+        return f"<Environment(id={self.id}, name={self.name}, organization_id={self.organization_id}, status={self.status})>"
+

control_plane_api/app/models/execution.py

@@ -0,0 +1,125 @@
+from sqlalchemy import Column, String, DateTime, Text, JSON, Enum as SQLEnum, ForeignKey, Index, desc
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from datetime import datetime
+import uuid
+import enum
+
+from control_plane_api.app.database import Base
+
+
+class ExecutionStatus(str, enum.Enum):
+    PENDING = "pending"
+    QUEUED = "queued"  # Message received and queued for processing
+    RUNNING = "running"
+    WAITING_FOR_INPUT = "waiting_for_input"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class ExecutionType(str, enum.Enum):
+    AGENT = "agent"
+    TEAM = "team"
+    WORKFLOW = "workflow"
+    PLAN_GENERATION = "plan_generation"
+
+
+class ExecutionTriggerSource(str, enum.Enum):
+    """How the execution was triggered"""
+    USER = "user"  # Triggered by a user directly via UI/API
+    JOB_CRON = "job_cron"  # Triggered by a scheduled job (cron)
+    JOB_WEBHOOK = "job_webhook"  # Triggered by a webhook job
+    JOB_MANUAL = "job_manual"  # Triggered manually through job trigger API
+    SYSTEM = "system"  # Triggered by system/automation
+    API = "api"  # Triggered directly via API
+    CHAT = "chat"  # Triggered from chat interface
+
+
+class Execution(Base):
+    """Model for tracking agent/team/workflow executions with user attribution"""
+
+    __tablename__ = "executions"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False)
+
+    # Organization
+    organization_id = Column(String(255), nullable=False, index=True)
+
+    # What is being executed
+    execution_type = Column(String(50), nullable=False)
+    entity_id = Column(UUID(as_uuid=True), nullable=False)  # agent_id, team_id, or workflow_id
+    entity_name = Column(String(255), nullable=True)  # Cached name for display
+    runner_name = Column(String(100), nullable=False)  # Cached runner name for filtering
+
+    # User attribution - who initiated this execution
+    user_id = Column(String(255), nullable=True, index=True)
+    user_email = Column(String(255), nullable=True)
+    user_name = Column(String(255), nullable=True)
+    user_avatar = Column(Text, nullable=True)
+
+    # Trigger source - how this execution was initiated
+    trigger_source = Column(
+        SQLEnum(ExecutionTriggerSource, name='executiontriggersource', values_callable=lambda x: [e.value for e in x]),
+        server_default=ExecutionTriggerSource.USER.value,
+        nullable=False,
+        index=True
+    )
+    trigger_metadata = Column(JSON, default={}, nullable=True)  # Additional context about the trigger (job_id, webhook payload, etc.)
+
+    # Execution details
+    prompt = Column(Text, nullable=False)
+    system_prompt = Column(Text, nullable=True)
+    config = Column(JSONB, default={}, nullable=True)
+
+    # Status and results
+    status = Column(String(50), default='pending', nullable=True)
+    response = Column(Text, nullable=True)
+    error_message = Column(Text, nullable=True)
+
+    # Temporal workflow information
+    temporal_workflow_id = Column(String(255), nullable=True, unique=True)
+    temporal_run_id = Column(String(255), nullable=True)
+
+    # Task queue information
+    task_queue_name = Column(String(100), default='default', nullable=True)
+
+    # Metadata
+    usage = Column(JSONB, default={}, nullable=True)  # Token usage, cost, etc.
+    execution_metadata = Column(JSONB, default={}, nullable=True)  # Additional metadata
+    plan_json = Column(JSONB, default={}, nullable=True)  # Generated plan (for PLAN_GENERATION type)
+
+    # Worker queue assignment
+    # Using SET NULL to preserve execution history when ephemeral queues are deleted
+    worker_queue_id = Column(UUID(as_uuid=True), ForeignKey('worker_queues.id', ondelete="SET NULL"), nullable=True, index=True)
+
+    # Timestamps
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=True)
+    started_at = Column(DateTime(timezone=True), nullable=True)
+    completed_at = Column(DateTime(timezone=True), nullable=True)
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=True)
+
+    # Relationships
+    participants = relationship("ExecutionParticipant", back_populates="execution", cascade="all, delete-orphan", lazy="selectin")
+    worker_queue = relationship("WorkerQueue", foreign_keys=[worker_queue_id])
+
+    __table_args__ = (
+        Index('idx_executions_workflow', 'temporal_workflow_id', postgresql_where='temporal_workflow_id IS NOT NULL'),
+        Index('idx_executions_run', 'temporal_run_id', postgresql_where='temporal_run_id IS NOT NULL'),
+        Index('idx_executions_runner', 'runner_name'),
+        Index('idx_executions_status', 'status'),
+        Index('idx_executions_user', 'user_id'),
+        Index('idx_executions_created', desc('created_at')),
+        Index('idx_executions_entity', 'entity_id'),
+        Index('idx_executions_org', 'organization_id'),
+        Index('idx_executions_task_queue', 'task_queue_name'),
+        Index('idx_executions_worker_queue_id', 'worker_queue_id'),
+        Index('idx_executions_user_id', 'user_id'),
+        Index('idx_executions_user_email', 'user_email'),
+        Index('ix_executions_trigger_source', 'trigger_source'),
+    )
+
+    def __repr__(self):
+        return f"<Execution {self.id} ({self.execution_type}:{self.entity_id}) - {self.status} by {self.user_email}>"

control_plane_api/app/models/execution_transition.py

@@ -0,0 +1,50 @@
+"""
+Execution Transition Model
+
+Tracks state transitions for executions with AI reasoning.
+"""
+
+from sqlalchemy import Column, String, Integer, DateTime, Boolean, JSON, ForeignKey
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql import func
+from datetime import datetime
+import uuid
+
+from control_plane_api.app.database import Base
+
+
+class ExecutionTransition(Base):
+    """Model for tracking execution state transitions with AI reasoning"""
+
+    __tablename__ = "execution_transitions"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False)
+
+    # Organization and execution references
+    organization_id = Column(String, nullable=False, index=True)
+    execution_id = Column(UUID(as_uuid=True), ForeignKey('executions.id', ondelete='CASCADE'), nullable=False, index=True)
+
+    # Turn context
+    turn_number = Column(Integer, nullable=False)
+
+    # State transition
+    from_state = Column(String(50), nullable=False)
+    to_state = Column(String(50), nullable=False)
+
+    # AI decision details
+    reasoning = Column(String, nullable=False)
+    confidence = Column(String(20), nullable=False)  # low, medium, high
+    decision_factors = Column(JSON, default={}, nullable=True)
+
+    # Model and timing
+    ai_model = Column(String(100), nullable=True)
+    decision_time_ms = Column(Integer, nullable=True)
+
+    # Manual override flag
+    is_manual_override = Column(Boolean, default=False, nullable=False)
+
+    # Timestamps
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+
+    def __repr__(self):
+        return f"<ExecutionTransition {self.id} ({self.from_state} → {self.to_state}) confidence={self.confidence}>"

control_plane_api/app/models/job.py

@@ -0,0 +1,159 @@
+from sqlalchemy import Column, String, DateTime, Text, JSON, Boolean, ForeignKey, Integer, Index
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+import uuid
+import enum
+
+from control_plane_api.app.database import Base
+
+
+class JobStatus(str, enum.Enum):
+    """Job status enumeration"""
+    ACTIVE = "active"
+    PAUSED = "paused"
+    FAILED = "failed"
+    DISABLED = "disabled"
+
+
+class JobTriggerType(str, enum.Enum):
+    """Job trigger type enumeration"""
+    CRON = "cron"
+    WEBHOOK = "webhook"
+    MANUAL = "manual"
+
+
+class ExecutorType(str, enum.Enum):
+    """Job executor routing type"""
+    AUTO = "auto"  # First available worker queue with active workers
+    SPECIFIC_QUEUE = "specific_queue"  # Explicit worker queue selection
+    ENVIRONMENT = "environment"  # Route to specific environment
+
+
+class PlanningMode(str, enum.Enum):
+    """Planning mode for job execution"""
+    ON_THE_FLY = "on_the_fly"  # Use planner to determine execution
+    PREDEFINED_AGENT = "predefined_agent"  # Execute specific agent
+    PREDEFINED_TEAM = "predefined_team"  # Execute specific team
+    PREDEFINED_WORKFLOW = "predefined_workflow"  # Execute specific workflow
+
+
+class Job(Base):
+    """
+    Model for scheduled and webhook-triggered jobs.
+
+    Jobs can be triggered via:
+    - Cron schedule (using Temporal Schedules)
+    - Webhook URL (with HMAC signature verification)
+    - Manual API trigger
+
+    Jobs execute agents, teams, or workflows with configurable routing.
+    """
+
+    __tablename__ = "jobs"
+
+    # Column order matches SQL schema
+    id = Column(String(255), primary_key=True, default=lambda: f"job_{uuid.uuid4()}", nullable=False)
+    organization_id = Column(String(255), nullable=False)
+    name = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+    enabled = Column(Boolean, default=True, nullable=False)
+    status = Column(
+        String(50),
+        default="active",
+        nullable=False
+    )
+    trigger_type = Column(
+        String(50),
+        nullable=False
+    )
+    cron_schedule = Column(String(255), nullable=True)
+    cron_timezone = Column(String(100), default="UTC", nullable=True)
+    webhook_url_path = Column(String(500), nullable=True, unique=True)
+    webhook_secret = Column(String(500), nullable=True)
+    temporal_schedule_id = Column(String(255), nullable=True, unique=True)
+    planning_mode = Column(
+        String(50),
+        default="predefined_agent",
+        nullable=False
+    )
+    entity_type = Column(String(50), nullable=True)
+    entity_id = Column(String(255), nullable=True)
+    entity_name = Column(String(255), nullable=True)
+    prompt_template = Column(Text, nullable=False)
+    system_prompt = Column(Text, nullable=True)
+    executor_type = Column(
+        String(50),
+        default="auto",
+        nullable=False
+    )
+    worker_queue_name = Column(String(255), nullable=True)
+    environment_name = Column(String(255), nullable=True)
+    config = Column(JSON, nullable=True, default={})
+    execution_environment = Column(JSON, nullable=True, default={})
+    last_execution_at = Column(DateTime(timezone=True), nullable=True)
+    next_execution_at = Column(DateTime(timezone=True), nullable=True)
+    total_executions = Column(Integer, default=0, nullable=False)
+    successful_executions = Column(Integer, default=0, nullable=False)
+    failed_executions = Column(Integer, default=0, nullable=False)
+    execution_history = Column(JSON, nullable=True, default=[])
+    created_by = Column(String(255), nullable=True)
+    updated_by = Column(String(255), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
+    last_triggered_at = Column(DateTime(timezone=True), nullable=True)
+    last_execution_id = Column(UUID(as_uuid=True), ForeignKey("executions.id", ondelete="SET NULL"), nullable=True)
+
+    # Relationships
+    last_execution = relationship("Execution", foreign_keys=[last_execution_id], lazy="select")
+
+    __table_args__ = (
+        Index('idx_jobs_organization_id', 'organization_id'),
+        Index('idx_jobs_name', 'organization_id', 'name'),
+        Index('idx_jobs_enabled', 'enabled'),
+        Index('idx_jobs_status', 'status'),
+        Index('idx_jobs_trigger_type', 'trigger_type'),
+        Index('idx_jobs_webhook_url_path', 'webhook_url_path'),
+        Index('idx_jobs_temporal_schedule_id', 'temporal_schedule_id'),
+        Index('idx_jobs_created_at', 'created_at'),
+        Index('idx_jobs_next_execution_at', 'next_execution_at'),
+    )
+
+    def __repr__(self):
+        return f"<Job {self.id} ({self.name}) - {self.trigger_type}:{self.status}>"
+
+
+class JobExecution(Base):
+    """
+    Junction table linking Jobs to Executions.
+    Tracks which executions were triggered by which jobs.
+    """
+
+    __tablename__ = "job_executions"
+
+    # Column order matches SQL schema
+    id = Column(String(255), primary_key=True, default=lambda: f"jobexec_{uuid.uuid4()}", nullable=False)
+    job_id = Column(String(255), ForeignKey("jobs.id", ondelete="CASCADE"), nullable=False)
+    organization_id = Column(String(255), nullable=False)
+    trigger_type = Column(String(50), nullable=False)
+    trigger_metadata = Column(JSON, nullable=True, default={})
+    execution_status = Column(String(50), nullable=True)
+    execution_duration_ms = Column(Integer, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    execution_id = Column(UUID(as_uuid=True), ForeignKey("executions.id", ondelete="CASCADE"), nullable=False)
+
+    # Relationships
+    job = relationship("Job", foreign_keys=[job_id], lazy="select")
+    execution = relationship("Execution", foreign_keys=[execution_id], lazy="select")
+
+    __table_args__ = (
+        Index('idx_job_executions_job_id', 'job_id'),
+        Index('idx_job_executions_organization_id', 'organization_id'),
+        Index('idx_job_executions_created_at', 'created_at'),
+        Index('idx_job_executions_trigger_type', 'trigger_type'),
+        Index('idx_job_executions_execution_status', 'execution_status'),
+        Index('idx_job_executions_execution_id', 'execution_id'),
+    )
+
+    def __repr__(self):
+        return f"<JobExecution job={self.job_id} execution={self.execution_id}>"

control_plane_api/app/models/llm_model.py

@@ -0,0 +1,78 @@
+"""LLM Model database model"""
+from sqlalchemy import Column, String, Boolean, Text, JSON, Integer
+from datetime import datetime
+from sqlalchemy import DateTime
+import uuid as uuid_module
+
+from control_plane_api.app.database import Base
+
+
+class LLMModel(Base):
+    """
+    LLM Model configuration for agent execution.
+
+    Stores available LLM models that can be used by agents and teams,
+    including provider information, compatibility, and UI metadata.
+    """
+
+    __tablename__ = "llm_models"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid_module.uuid4()))
+
+    # Model identification
+    value = Column(String, unique=True, nullable=False, index=True)
+    label = Column(String, nullable=False)
+    provider = Column(String, nullable=False, index=True)
+    model_type = Column(String, default="text-generation", nullable=False, index=True)
+    # Model type: "text-generation" (LLM), "embedding" (embedding model), "multimodal", etc.
+
+    # UI metadata
+    logo = Column(String, nullable=True)
+    description = Column(Text, nullable=True)
+
+    # Status and flags
+    enabled = Column(Boolean, default=True, nullable=False, index=True)
+    recommended = Column(Boolean, default=False, nullable=False)
+
+    # Runtime compatibility
+    # Store list of compatible runtime types (e.g., ["default", "claude_code"])
+    compatible_runtimes = Column(JSON, default=list, nullable=False)
+
+    # Model capabilities and metadata
+    capabilities = Column(JSON, default=dict, nullable=False)
+    # Example: {"vision": true, "function_calling": true, "max_tokens": 4096}
+
+    # Pricing information (optional)
+    pricing = Column(JSON, default=dict, nullable=True)
+    # Example: {"input_cost_per_1k": 0.01, "output_cost_per_1k": 0.03}
+
+    # Display order (lower = shown first)
+    display_order = Column(Integer, default=1000, nullable=False)
+
+    # Metadata
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    created_by = Column(String, nullable=True)  # User ID who created this model entry
+
+    def __repr__(self):
+        return f"<LLMModel(id={self.id}, value={self.value}, provider={self.provider})>"
+
+    def to_dict(self):
+        """Convert to dictionary for API responses"""
+        return {
+            "id": self.id,
+            "value": self.value,
+            "label": self.label,
+            "provider": self.provider,
+            "model_type": self.model_type,
+            "logo": self.logo,
+            "description": self.description,
+            "enabled": self.enabled,
+            "recommended": self.recommended,
+            "compatible_runtimes": self.compatible_runtimes,
+            "capabilities": self.capabilities,
+            "pricing": self.pricing,
+            "display_order": self.display_order,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+        }

control_plane_api/app/models/orchestration.py

@@ -0,0 +1,66 @@
+"""Orchestration and namespace models"""
+from sqlalchemy import Column, String, DateTime, Text, JSON, UUID, CheckConstraint, Index, UniqueConstraint, text
+from sqlalchemy.sql import func
+from datetime import datetime
+import uuid
+
+from control_plane_api.app.database import Base
+
+
+class Namespace(Base):
+    """Model for Temporal Cloud namespaces provisioned for each organization"""
+
+    __tablename__ = "namespaces"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, server_default=text('gen_random_uuid()'), nullable=False)
+    organization_id = Column(String(255), nullable=False)
+    namespace_name = Column(String(255), nullable=False)
+    status = Column(String(50), server_default=text("'provisioning'::character varying"), nullable=False)
+    temporal_host = Column(String(255), nullable=True)
+    api_key_encrypted = Column(Text, nullable=True)
+
+    # Metadata
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=True)
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=True)
+
+    __table_args__ = (
+        UniqueConstraint('namespace_name', name='namespaces_namespace_name_key'),
+        Index('idx_namespaces_organization_id', 'organization_id'),
+        Index('idx_namespaces_status', 'status'),
+    )
+
+    def __repr__(self):
+        return f"<Namespace(namespace_name={self.namespace_name}, status={self.status})>"
+
+
+class TemporalNamespace(Base):
+    """Model for Temporal Cloud namespaces provisioned per organization"""
+
+    __tablename__ = "temporal_namespaces"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, server_default=text('gen_random_uuid()'), nullable=False)
+    organization_id = Column(String(255), nullable=False)
+    namespace_name = Column(String(255), nullable=False)
+    account_id = Column(String(255), nullable=True)
+    region = Column(String(50), server_default=text("'aws-us-east-1'::character varying"), nullable=True)
+    api_key_encrypted = Column(Text, nullable=True)
+    certificate_encrypted = Column(Text, nullable=True)
+    status = Column(String(50), server_default=text("'pending'::character varying"), nullable=True)
+    provisioning_workflow_id = Column(String(255), nullable=True)
+    error_message = Column(Text, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=True)
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=True)
+    provisioned_at = Column(DateTime(timezone=True), nullable=True)
+    created_by = Column(String(255), nullable=True)
+
+    __table_args__ = (
+        CheckConstraint(
+            "status::text = ANY (ARRAY['pending'::character varying, 'provisioning'::character varying, 'ready'::character varying, 'error'::character varying, 'archived'::character varying]::text[])",
+            name='temporal_namespaces_status_check'
+        ),
+        Index('idx_temporal_namespaces_organization_id', 'organization_id'),
+        Index('idx_temporal_namespaces_status', 'status'),
+    )
+
+    def __repr__(self):
+        return f"<TemporalNamespace(namespace_name={self.namespace_name}, status={self.status}, organization_id={self.organization_id})>"