types

type AnthropicConfig struct {
	APIKey string `key:"apiKey" json:"api_key"`
}

type AppConfig struct {
	Mode       string `key:"mode" json:"mode"` // "local" or "remote"
	DebugMode  bool   `key:"debugMode" json:"debug_mode"`
	PrettyLogs bool   `key:"prettyLogs" json:"pretty_logs"`

	ClusterName string           `key:"clusterName" json:"cluster_name"`
	Database    DatabaseConfig   `key:"database" json:"database"`
	Image       ImageConfig      `key:"image" json:"image"`
	Sandbox     SandboxSettings  `key:"sandbox" json:"sandbox"`
	Filesystem  FilesystemConfig `key:"filesystem" json:"filesystem"`
	Gateway     GatewayConfig    `key:"gateway" json:"gateway"`
	Scheduler   SchedulerConfig  `key:"scheduler" json:"scheduler"`
	Tools       ToolsConfig      `key:"tools" json:"tools"`
	OAuth       IntegrationOAuth `key:"oauth" json:"oauth"`     // OAuth for workspace integrations (gmail, gdrive)
	Streams     StreamsConfig    `key:"streams" json:"streams"` // S2 stream configuration for task logs
	Anthropic   AnthropicConfig  `key:"anthropic" json:"anthropic"`
}

type AuthInfo struct {
	TokenType TokenType
	Workspace *WorkspaceInfo
	Member    *MemberInfo
	Worker    *WorkerInfo
}

type CORSConfig struct {
	AllowedOrigins []string `key:"allowOrigins" json:"allow_origins"`
	AllowedMethods []string `key:"allowMethods" json:"allow_methods"`
	AllowedHeaders []string `key:"allowHeaders" json:"allow_headers"`
}

type ContainerRuntime string

type CreateWorkspaceToolRequest struct {
	Name         string           `json:"name"`
	ProviderType string           `json:"provider_type"` // "mcp"
	MCP          *MCPServerConfig `json:"mcp,omitempty"`
}

type DatabaseConfig struct {
	Redis    RedisConfig    `key:"redis" json:"redis"`
	Postgres PostgresConfig `key:"postgres" json:"postgres"`
}

type DirEntry struct {
	Name   string `json:"name"`
	Mode   uint32 `json:"mode"`
	Size   int64  `json:"size,omitempty"`
	Mtime  int64  `json:"mtime,omitempty"` // Unix timestamp
	IsLink bool   `json:"is_link,omitempty"`
}

type DirMeta struct {
	Path     string    `json:"path"`
	Mode     uint32    `json:"mode"`
	Uid      uint32    `json:"uid"`
	Gid      uint32    `json:"gid"`
	Mtime    time.Time `json:"mtime"`
	Children []string  `json:"children"` // Entry names in this directory
}

type ErrTaskNotFound struct {
	ExternalId string
}

type ErrWorkerNotFound struct {
	WorkerId string
}

type ErrWorkerPoolNotFound struct {
	PoolName string
}

type ErrWorkspaceNotFound struct {
	ExternalId string
	Name       string
}

type ErrWorkspaceToolExists struct {
	Name string
}

type ErrWorkspaceToolNotFound struct {
	Name       string
	ExternalId string
}

type FileMeta struct {
	Path    string    `json:"path"`
	Size    int64     `json:"size"`
	Mode    uint32    `json:"mode"`
	Uid     uint32    `json:"uid"`
	Gid     uint32    `json:"gid"`
	Mtime   time.Time `json:"mtime"`
	S3Key   string    `json:"s3_key,omitempty"`  // Object storage key (for context files)
	Symlink string    `json:"symlink,omitempty"` // Target path if symlink (empty otherwise)
}

type FilesystemConfig struct {
	MountPoint       string                 `key:"mountPoint" json:"mount_point"`
	Verbose          bool                   `key:"verbose" json:"verbose"`
	WorkspaceStorage WorkspaceStorageConfig `key:"workspaceStorage" json:"workspace_storage"`
}

type FilesystemQuery struct {
	Id             uint              `json:"id" db:"id"`
	ExternalId     string            `json:"external_id" db:"external_id"`
	WorkspaceId    uint              `json:"workspace_id" db:"workspace_id"`
	Integration    string            `json:"integration" db:"integration"`         // "gmail", "gdrive", "notion"
	Path           string            `json:"path" db:"path"`                       // Full path: "/sources/gmail/unread-emails"
	Name           string            `json:"name" db:"name"`                       // Folder/file name: "unread-emails"
	QuerySpec      string            `json:"query_spec" db:"query_spec"`           // JSON query params from LLM
	Guidance       string            `json:"guidance" db:"guidance"`               // Optional user-provided context
	OutputFormat   QueryOutputFormat `json:"output_format" db:"output_format"`     // "folder" or "file"
	FileExt        string            `json:"file_ext" db:"file_ext"`               // For files: ".json", ".md"
	FilenameFormat string            `json:"filename_format" db:"filename_format"` // Template for result filenames (e.g., "{date}_{subject}_{id}.txt")
	CacheTTL       int               `json:"cache_ttl" db:"cache_ttl"`             // Seconds, 0 = always live
	CreatedAt      time.Time         `json:"created_at" db:"created_at"`
	UpdatedAt      time.Time         `json:"updated_at" db:"updated_at"`
	LastExecuted   *time.Time        `json:"last_executed,omitempty" db:"last_executed"`
}

type GRPCConfig struct {
	Port           int `key:"port" json:"port"`
	MaxRecvMsgSize int `key:"maxRecvMsgSize" json:"max_recv_msg_size"`
	MaxSendMsgSize int `key:"maxSendMsgSize" json:"max_send_msg_size"`
}

type GatewayConfig struct {
	GRPC            GRPCConfig    `key:"grpc" json:"grpc"`
	HTTP            HTTPConfig    `key:"http" json:"http"`
	ShutdownTimeout time.Duration `key:"shutdownTimeout" json:"shutdown_timeout"`
	AuthToken       string        `key:"authToken" json:"auth_token"`
}

type GitHubConfig struct {
	Enabled bool `key:"enabled" json:"enabled"`
}

type HTTPConfig struct {
	Host             string     `key:"host" json:"host"`
	Port             int        `key:"port" json:"port"`
	EnablePrettyLogs bool       `key:"enablePrettyLogs" json:"enable_pretty_logs"`
	CORS             CORSConfig `key:"cors" json:"cors"`
}

type IPAllocation struct {
	IP        string `json:"ip"`
	Gateway   string `json:"gateway"`
	PrefixLen int    `json:"prefix_len"`
}

type ImageConfig struct {
	S3        S3Config `key:"s3" json:"s3"`
	CachePath string   `key:"cachePath" json:"cache_path"`
	WorkPath  string   `key:"workPath" json:"work_path"`
	MountPath string   `key:"mountPath" json:"mount_path"`
}

type IntegrationAPIKey struct {
	APIKey string `key:"apiKey" json:"api_key"`
}

type IntegrationAuthType string

type IntegrationConnection struct {
	Id              uint       `db:"id" json:"id"`
	ExternalId      string     `db:"external_id" json:"external_id"`
	WorkspaceId     uint       `db:"workspace_id" json:"workspace_id"`
	MemberId        *uint      `db:"member_id" json:"member_id,omitempty"` // nil = workspace-shared
	IntegrationType string     `db:"integration_type" json:"integration_type"`
	Credentials     []byte     `db:"credentials" json:"-"` // Encrypted
	Scope           string     `db:"scope" json:"scope,omitempty"`
	ExpiresAt       *time.Time `db:"expires_at" json:"expires_at,omitempty"`
	CreatedAt       time.Time  `db:"created_at" json:"created_at"`
	UpdatedAt       time.Time  `db:"updated_at" json:"updated_at"`
}

type IntegrationCredentials struct {
	AccessToken  string            `json:"access_token,omitempty"`
	RefreshToken string            `json:"refresh_token,omitempty"`
	APIKey       string            `json:"api_key,omitempty"`
	ExpiresAt    *time.Time        `json:"expires_at,omitempty"`
	Extra        map[string]string `json:"extra,omitempty"`
}

type IntegrationMeta struct {
	Tool        ToolName
	DisplayName string
	Description string
	Icon        string
	AuthType    IntegrationAuthType
	Scope       IntegrationScope
}

type IntegrationOAuth struct {
	CallbackURL string                   `key:"callbackUrl" json:"callback_url"` // e.g., https://api.airstore.ai/api/v1/oauth/callback
	Google      ProviderOAuthCredentials `key:"google" json:"google"`
	GitHub      ProviderOAuthCredentials `key:"github" json:"github"`
	Notion      ProviderOAuthCredentials `key:"notion" json:"notion"`
	Slack       ProviderOAuthCredentials `key:"slack" json:"slack"`
	Linear      ProviderOAuthCredentials `key:"linear" json:"linear"`
}

type IntegrationScope string

type IntegrationsConfig struct {
	Weather IntegrationAPIKey `key:"weather" json:"weather"`
	Exa     IntegrationAPIKey `key:"exa" json:"exa"`
	GitHub  GitHubConfig      `key:"github" json:"github"`
}

type MCPAuthConfig struct {
	// Token is the bearer token for authentication.
	// For stdio: passed as MCP_AUTH_TOKEN env var (or custom var via TokenEnv)
	// For remote: passed as Authorization: Bearer <token> header
	Token string `key:"token" json:"token,omitempty"`

	// TokenEnv specifies a custom env var name for the token (stdio only, default: MCP_AUTH_TOKEN)
	TokenEnv string `key:"tokenEnv" json:"token_env,omitempty"`

	// Headers are additional auth headers.
	// For stdio: passed as MCP_AUTH_HEADER_<NAME> env vars
	// For remote: passed directly as HTTP headers
	Headers map[string]string `key:"headers" json:"headers,omitempty"`
}

type MCPServerConfig struct {
	// Local (stdio) server - spawn process
	Command    string            `key:"command" json:"command,omitempty"` // Executable (npx, uvx, python)
	Args       []string          `key:"args" json:"args,omitempty"`       // Command arguments
	Env        map[string]string `key:"env" json:"env,omitempty"`         // Environment variables
	WorkingDir string            `key:"cwd" json:"cwd,omitempty"`         // Working directory

	// Remote (HTTP/SSE) server - connect to URL
	URL string `key:"url" json:"url,omitempty"`

	// Transport specifies the remote transport type: "sse" (default) or "http" (Streamable HTTP)
	Transport string `key:"transport" json:"transport,omitempty"`

	// Auth for both local (env vars) and remote (HTTP headers)
	Auth *MCPAuthConfig `key:"auth" json:"auth,omitempty"`
}

type MemberInfo struct {
	Id         uint
	ExternalId string
	Email      string
	Role       MemberRole
}

type MemberRole string

type MetadataNotFoundError struct {
	Key string
}

type PoolScalerStatus struct {
	PoolName        string `json:"pool_name"`
	QueueDepth      int64  `json:"queue_depth"`
	InFlightTasks   int64  `json:"in_flight_tasks"`
	CurrentReplicas int32  `json:"current_replicas"`
	MinReplicas     int32  `json:"min_replicas"`
	MaxReplicas     int32  `json:"max_replicas"`
}

type PostgresConfig struct {
	Host            string        `key:"host" json:"host"`
	Port            int           `key:"port" json:"port"`
	User            string        `key:"user" json:"user"`
	Password        string        `key:"password" json:"password"`
	Database        string        `key:"database" json:"database"`
	SSLMode         string        `key:"sslMode" json:"ssl_mode"`
	MaxOpenConns    int           `key:"maxOpenConns" json:"max_open_conns"`
	MaxIdleConns    int           `key:"maxIdleConns" json:"max_idle_conns"`
	ConnMaxLifetime time.Duration `key:"connMaxLifetime" json:"conn_max_lifetime"`
}

type ProviderOAuthCredentials struct {
	ClientID     string `key:"clientId" json:"client_id"`
	ClientSecret string `key:"clientSecret" json:"client_secret"`
}

type QueryOutputFormat string

type RedisConfig struct {
	Mode               RedisMode     `key:"mode" json:"mode"`
	Addrs              []string      `key:"addrs" json:"addrs"`
	Username           string        `key:"username" json:"username"`
	Password           string        `key:"password" json:"password"`
	ClientName         string        `key:"clientName" json:"client_name"`
	EnableTLS          bool          `key:"enableTLS" json:"enable_tls"`
	InsecureSkipVerify bool          `key:"insecureSkipVerify" json:"insecure_skip_verify"`
	PoolSize           int           `key:"poolSize" json:"pool_size"`
	MinIdleConns       int           `key:"minIdleConns" json:"min_idle_conns"`
	MaxIdleConns       int           `key:"maxIdleConns" json:"max_idle_conns"`
	ConnMaxIdleTime    time.Duration `key:"connMaxIdleTime" json:"conn_max_idle_time"`
	ConnMaxLifetime    time.Duration `key:"connMaxLifetime" json:"conn_max_lifetime"`
	DialTimeout        time.Duration `key:"dialTimeout" json:"dial_timeout"`
	ReadTimeout        time.Duration `key:"readTimeout" json:"read_timeout"`
	WriteTimeout       time.Duration `key:"writeTimeout" json:"write_timeout"`
	MaxRedirects       int           `key:"maxRedirects" json:"max_redirects"`
	MaxRetries         int           `key:"maxRetries" json:"max_retries"`
	RouteByLatency     bool          `key:"routeByLatency" json:"route_by_latency"`
}

type RedisMode string

type ResolvedTool struct {
	Name       string              `json:"name"`
	Help       string              `json:"help,omitempty"`
	Origin     WorkspaceToolOrigin `json:"origin"`
	ExternalId string              `json:"external_id,omitempty"` // Only for workspace tools
	Enabled    bool                `json:"enabled"`
	ToolCount  int                 `json:"tool_count,omitempty"` // For MCP servers
}

type S3Config struct {
	Bucket         string `key:"bucket" json:"bucket"`
	Region         string `key:"region" json:"region"`
	Endpoint       string `key:"endpoint" json:"endpoint"`
	AccessKey      string `key:"accessKey" json:"access_key"`
	SecretKey      string `key:"secretKey" json:"secret_key"`
	ForcePathStyle bool   `key:"forcePathStyle" json:"force_path_style"`
}

type SandboxConfig struct {
	// ID is the unique identifier for this sandbox
	ID string `json:"id"`

	// WorkspaceID is the workspace this sandbox belongs to
	WorkspaceID string `json:"workspace_id"`

	// Image is the container image to use for the sandbox
	Image string `json:"image"`

	// Runtime is the container runtime to use (runc, gvisor)
	Runtime ContainerRuntime `json:"runtime"`

	// Entrypoint is the command to run in the sandbox
	Entrypoint []string `json:"entrypoint"`

	// Env is the environment variables to set
	Env map[string]string `json:"env"`

	// WorkingDir is the working directory inside the sandbox
	WorkingDir string `json:"working_dir"`

	// Resources specifies resource limits for the sandbox
	Resources TaskResources `json:"resources"`

	// Mounts specifies additional mounts for the sandbox
	Mounts []SandboxMount `json:"mounts"`

	// Network specifies network configuration
	Network SandboxNetwork `json:"network"`

	// FilesystemMount is the host path to bind-mount at /workspace (optional)
	FilesystemMount string `json:"-"`
}

type SandboxMount struct {
	// Source is the host path or volume name
	Source string `json:"source"`

	// Destination is the path inside the sandbox
	Destination string `json:"destination"`

	// ReadOnly specifies if the mount is read-only
	ReadOnly bool `json:"read_only"`

	// Type is the mount type (bind, volume, tmpfs)
	Type string `json:"type"`
}

type SandboxNetwork struct {
	// Mode is the network mode (none, host, bridge)
	Mode string `json:"mode"`

	// ExposedPorts is a list of ports to expose
	ExposedPorts []int `json:"exposed_ports"`
}

type SandboxSettings struct {
	// DefaultImage is the container image used for Claude Code tasks
	DefaultImage string `key:"defaultImage" json:"default_image"`
}

type SandboxState struct {
	// ID is the sandbox identifier
	ID string `json:"id"`

	// Status is the current status
	Status SandboxStatus `json:"status"`

	// PID is the main process ID (0 if not running)
	PID int `json:"pid"`

	// ExitCode is the exit code if stopped (-1 if still running)
	ExitCode int `json:"exit_code"`

	// Error contains error message if failed
	Error string `json:"error,omitempty"`

	// ContainerIP is the container's IP address (for routing)
	ContainerIP string `json:"container_ip,omitempty"`

	// CreatedAt is when the sandbox was created
	CreatedAt time.Time `json:"created_at"`

	// StartedAt is when the sandbox started running
	StartedAt time.Time `json:"started_at,omitempty"`

	// FinishedAt is when the sandbox stopped
	FinishedAt time.Time `json:"finished_at,omitempty"`
}

type SandboxStatus string

type SchedulerConfig struct {
	Enabled               bool                        `key:"enabled" json:"enabled"`
	GatewayServiceName    string                      `key:"gatewayServiceName" json:"gateway_service_name"`
	WorkerImage           string                      `key:"workerImage" json:"worker_image"`
	WorkerNamespace       string                      `key:"workerNamespace" json:"worker_namespace"`
	WorkerTTL             time.Duration               `key:"workerTTL" json:"worker_ttl"`
	WorkerShutdownTimeout time.Duration               `key:"workerShutdownTimeout" json:"worker_shutdown_timeout"` // Time to wait for tasks during graceful shutdown
	CleanupInterval       time.Duration               `key:"cleanupInterval" json:"cleanup_interval"`
	HeartbeatInterval     time.Duration               `key:"heartbeatInterval" json:"heartbeat_interval"`
	HeartbeatTimeout      time.Duration               `key:"heartbeatTimeout" json:"heartbeat_timeout"`
	DefaultWorkerCpu      int64                       `key:"defaultWorkerCpu" json:"default_worker_cpu"`
	DefaultWorkerMemory   int64                       `key:"defaultWorkerMemory" json:"default_worker_memory"`
	Pools                 map[string]WorkerPoolConfig `key:"pools" json:"pools"`
}

type SmartQuery = FilesystemQuery

type SmartQueryOutputFormat = QueryOutputFormat

type StreamsConfig struct {
	Token string `key:"token" json:"token"` // S2 API token
	Basin string `key:"basin" json:"basin"` // S2 basin name (e.g., "airstore")
}

type Task struct {
	// Id is the internal ID for joins
	Id uint `json:"id" db:"id"`

	// ExternalId is the UUID exposed via API
	ExternalId string `json:"external_id" db:"external_id"`

	// WorkspaceId is the internal workspace ID (for joins)
	WorkspaceId uint `json:"workspace_id" db:"workspace_id"`

	// CreatedByMemberId is the member who created this task (for token auth)
	CreatedByMemberId *uint `json:"created_by_member_id,omitempty" db:"created_by_member_id"`

	// MemberToken is the workspace token to use for filesystem access
	// This is NOT stored in the database - it's set at creation time and passed to workers
	MemberToken string `json:"member_token,omitempty" db:"-"`

	// Status is the current task status
	Status TaskStatus `json:"status" db:"status"`

	// Prompt is the Claude Code prompt (if this is a Claude Code task)
	Prompt string `json:"prompt,omitempty" db:"prompt"`

	// Image is the container image to use
	Image string `json:"image" db:"image"`

	// Entrypoint is the command to run
	Entrypoint []string `json:"entrypoint" db:"entrypoint"`

	// Env is environment variables for the task
	Env map[string]string `json:"env" db:"env"`

	// Resources specifies resource requirements (optional - uses defaults if nil)
	Resources *TaskResources `json:"resources,omitempty" db:"-"`

	// ExitCode is the exit code when complete
	ExitCode *int `json:"exit_code,omitempty" db:"exit_code"`

	// Error contains error message if failed
	Error string `json:"error,omitempty" db:"error"`

	// CreatedAt is when the task was created
	CreatedAt time.Time `json:"created_at" db:"created_at"`

	// StartedAt is when the task started running
	StartedAt *time.Time `json:"started_at,omitempty" db:"started_at"`

	// FinishedAt is when the task finished
	FinishedAt *time.Time `json:"finished_at,omitempty" db:"finished_at"`
}

type TaskResources struct {
	CPU    int64 `json:"cpu"`    // millicores (1000 = 1 CPU)
	Memory int64 `json:"memory"` // bytes
	GPU    int   `json:"gpu"`    // count
}

type TaskResult struct {
	// ID is the task identifier
	ID string `json:"id"`

	// ExitCode is the exit code of the task
	ExitCode int `json:"exit_code"`

	// Output is the stdout/stderr output (if captured)
	Output []byte `json:"output,omitempty"`

	// Error contains error message if failed
	Error string `json:"error,omitempty"`

	// Duration is how long the task ran
	Duration time.Duration `json:"duration"`
}

type TaskState struct {
	// ID is the task identifier
	ID string `json:"id"`

	// Status is the current status
	Status TaskStatus `json:"status"`

	// SandboxID is the sandbox running this task (empty if not yet scheduled)
	SandboxID string `json:"sandbox_id,omitempty"`

	// WorkerID is the worker running this task (empty if not yet scheduled)
	WorkerID string `json:"worker_id,omitempty"`

	// ExitCode is the exit code if complete (-1 if still running)
	ExitCode int `json:"exit_code"`

	// Error contains error message if failed
	Error string `json:"error,omitempty"`

	// CreatedAt is when the task was created
	CreatedAt time.Time `json:"created_at"`

	// ScheduledAt is when the task was scheduled
	ScheduledAt time.Time `json:"scheduled_at,omitempty"`

	// StartedAt is when the task started running
	StartedAt time.Time `json:"started_at,omitempty"`

	// FinishedAt is when the task finished
	FinishedAt time.Time `json:"finished_at,omitempty"`
}

type TaskStatus string

type Token struct {
	Id          uint       `db:"id" json:"id"`
	ExternalId  string     `db:"external_id" json:"external_id"`
	WorkspaceId *uint      `db:"workspace_id" json:"workspace_id,omitempty"`
	MemberId    *uint      `db:"member_id" json:"member_id,omitempty"`
	TokenType   TokenType  `db:"token_type" json:"token_type"`
	TokenHash   string     `db:"token_hash" json:"-"`
	Name        string     `db:"name" json:"name"`
	PoolName    *string    `db:"pool_name" json:"pool_name,omitempty"`
	ExpiresAt   *time.Time `db:"expires_at" json:"expires_at,omitempty"`
	CreatedAt   time.Time  `db:"created_at" json:"created_at"`
	LastUsedAt  *time.Time `db:"last_used_at" json:"last_used_at,omitempty"`
}

type TokenType string

type TokenValidationResult struct {
	// Workspace fields (set for workspace_member tokens)
	WorkspaceId   uint
	WorkspaceExt  string
	WorkspaceName string
	MemberId      uint
	MemberExt     string
	MemberEmail   string
	MemberRole    MemberRole

	// Worker fields (set for worker tokens)
	PoolName string

	// Common
	TokenType TokenType
}

type ToolName string

type ToolsConfig struct {
	// Builtin API-key integrations
	Integrations IntegrationsConfig `key:"integrations" json:"integrations"`

	// External MCP servers (tools auto-discovered and exposed as POSIX commands)
	MCP map[string]MCPServerConfig `key:"mcp" json:"mcp"`
}

type VirtualFile struct {
	ID         string                 `json:"id"`
	Name       string                 `json:"name"`
	Path       string                 `json:"path"`
	Type       VirtualFileType        `json:"type"`
	IsFolder   bool                   `json:"is_folder"`
	IsSymlink  bool                   `json:"is_symlink,omitempty"`
	IsReadOnly bool                   `json:"is_readonly,omitempty"`
	Size       int64                  `json:"size,omitempty"`
	ModifiedAt *time.Time             `json:"modified_at,omitempty"`
	ChildCount int                    `json:"child_count,omitempty"`
	Metadata   map[string]interface{} `json:"metadata,omitempty"`
}

type VirtualFileListResponse struct {
	Path    string        `json:"path"`
	Entries []VirtualFile `json:"entries"`
}

type VirtualFileSearchResponse struct {
	Query   string        `json:"query"`
	Results []VirtualFile `json:"results"`
}

type VirtualFileTreeResponse struct {
	Path    string        `json:"path"`
	Depth   int           `json:"depth"`
	Entries []VirtualFile `json:"entries"`
}

type VirtualFileType string

type Worker struct {
	ID           string       `json:"id" redis:"id"`
	Status       WorkerStatus `json:"status" redis:"status"`
	PoolName     string       `json:"pool_name" redis:"pool_name"`
	Hostname     string       `json:"hostname" redis:"hostname"`
	Cpu          int64        `json:"cpu" redis:"cpu"`
	Memory       int64        `json:"memory" redis:"memory"`
	LastSeenAt   time.Time    `json:"last_seen_at" redis:"last_seen_at"`
	RegisteredAt time.Time    `json:"registered_at" redis:"registered_at"`
	Version      string       `json:"version" redis:"version"`
}

type WorkerInfo struct {
	PoolName string
}

type WorkerJobOpts struct {
	PoolName  string
	Cpu       int64
	Memory    int64
	Image     string
	Namespace string
	Labels    map[string]string
	Env       map[string]string
}

type WorkerPaths struct {
	// BundleDir is where sandbox bundles are created
	BundleDir string `key:"bundleDir" json:"bundle_dir"`

	// StateDir is where overlay state is stored (should be tmpfs)
	StateDir string `key:"stateDir" json:"state_dir"`

	// MountDir is where per-task FUSE mounts are created
	MountDir string `key:"mountDir" json:"mount_dir"`

	// CLIBinary is the path to the CLI binary for mounting
	CLIBinary string `key:"cliBinary" json:"cli_binary"`

	// WorkerMount is the global worker FUSE mount path
	WorkerMount string `key:"workerMount" json:"worker_mount"`
}

type WorkerPoolConfig struct {
	// DeploymentName is the K8s Deployment to scale (auto-generated if empty)
	DeploymentName string `key:"deploymentName" json:"deployment_name"`

	// Namespace is the K8s namespace
	Namespace string `key:"namespace" json:"namespace"`

	// MinReplicas is the minimum number of workers
	MinReplicas int32 `key:"minReplicas" json:"min_replicas"`

	// MaxReplicas is the maximum number of workers
	MaxReplicas int32 `key:"maxReplicas" json:"max_replicas"`

	// ScaleDownDelay is how long queue must be empty before scaling down
	ScaleDownDelay time.Duration `key:"scaleDownDelay" json:"scale_down_delay"`

	// Cpu is the CPU request/limit for workers (e.g., "500m", "1")
	Cpu string `key:"cpu" json:"cpu"`

	// Memory is the memory request/limit for workers (e.g., "512Mi", "1Gi")
	Memory string `key:"memory" json:"memory"`
}

type WorkerPoolState struct {
	Name             string           `json:"name"`
	Status           WorkerPoolStatus `json:"status"`
	TotalWorkers     int              `json:"total_workers"`
	AvailableWorkers int              `json:"available_workers"`
}

type WorkerPoolStatus string

type WorkerStatus string

type Workspace struct {
	Id         uint      `json:"id" db:"id"`                   // Internal ID for joins
	ExternalId string    `json:"external_id" db:"external_id"` // External UUID for API
	Name       string    `json:"name" db:"name"`
	CreatedAt  time.Time `json:"created_at" db:"created_at"`
	UpdatedAt  time.Time `json:"updated_at" db:"updated_at"`
}

type WorkspaceInfo struct {
	Id         uint
	ExternalId string
	Name       string
}

type WorkspaceMember struct {
	Id          uint       `db:"id" json:"id"`
	ExternalId  string     `db:"external_id" json:"external_id"`
	WorkspaceId uint       `db:"workspace_id" json:"workspace_id"`
	Email       string     `db:"email" json:"email"`
	Name        string     `db:"name" json:"name"`
	Role        MemberRole `db:"role" json:"role"`
	CreatedAt   time.Time  `db:"created_at" json:"created_at"`
	UpdatedAt   time.Time  `db:"updated_at" json:"updated_at"`
}

type WorkspaceStorageConfig struct {
	DefaultBucketPrefix string `key:"defaultBucketPrefix" json:"default_bucket_prefix"`
	DefaultAccessKey    string `key:"defaultAccessKey" json:"default_access_key"`
	DefaultSecretKey    string `key:"defaultSecretKey" json:"default_secret_key"`
	DefaultEndpointUrl  string `key:"defaultEndpointUrl" json:"default_endpoint_url"`
	DefaultRegion       string `key:"defaultRegion" json:"default_region"`
}

type WorkspaceTool struct {
	Id                uint                      `json:"id" db:"id"`
	ExternalId        string                    `json:"external_id" db:"external_id"`
	WorkspaceId       uint                      `json:"workspace_id" db:"workspace_id"`
	Name              string                    `json:"name" db:"name"`
	ProviderType      WorkspaceToolProviderType `json:"provider_type" db:"provider_type"`
	Config            json.RawMessage           `json:"config" db:"config"`               // Serialized MCPServerConfig
	Manifest          json.RawMessage           `json:"manifest,omitempty" db:"manifest"` // Cached tools/list output
	CreatedByMemberId *uint                     `json:"created_by_member_id,omitempty" db:"created_by_member_id"`
	CreatedAt         time.Time                 `json:"created_at" db:"created_at"`
	UpdatedAt         time.Time                 `json:"updated_at" db:"updated_at"`
}

type WorkspaceToolOrigin string

type WorkspaceToolProviderType string

type WorkspaceToolResponse struct {
	ExternalId   string    `json:"external_id"`
	Name         string    `json:"name"`
	ProviderType string    `json:"provider_type"`
	ToolCount    int       `json:"tool_count,omitempty"`
	CreatedAt    time.Time `json:"created_at"`
	UpdatedAt    time.Time `json:"updated_at"`
}

type WorkspaceToolSetting struct {
	Id          uint      `json:"id" db:"id"`
	WorkspaceId uint      `json:"workspace_id" db:"workspace_id"`
	ToolName    string    `json:"tool_name" db:"tool_name"`
	Enabled     bool      `json:"enabled" db:"enabled"`
	CreatedAt   time.Time `json:"created_at" db:"created_at"`
	UpdatedAt   time.Time `json:"updated_at" db:"updated_at"`
}

type WorkspaceToolSettings struct {
	WorkspaceId uint
	// DisabledTools is a set of tool names that are disabled
	// Tools not in this map are enabled by default
	DisabledTools map[string]bool
}