Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

25.3 KB
Raw Blame
import { get, post, put, del } from '@/utils/request'

// Organization types
export interface Organization {
  id: string
  name: string
  description: string
  avatar?: string
  owner_id: string
  /**
   * Persisted owner tenant of the organization (Plan 3, migration 000046).
   * After Plan 3, member ownership is tenant-keyed: identifying the
   * "owner row" in the members list means matching member.tenant_id
   * against owner_tenant_id (NOT member.user_id against owner_id).
   * May be 0 on pre-000046 legacy rows; in that case fall back to
   * owner_id for display only.
   */
  owner_tenant_id: number
  invite_code?: string
  invite_code_expires_at?: string | null
  invite_code_validity_days?: number
  require_approval?: boolean
  searchable?: boolean
  /** Max members; 0 = unlimited */
  member_limit?: number
  member_count?: number
  share_count?: number
  agent_share_count?: number
  pending_join_request_count?: number
  is_owner?: boolean
  my_role?: string
  has_pending_upgrade?: boolean
  created_at: string
  updated_at: string
}

/**
 * OrganizationMember represents one row in the organization's per-tenant
 * member list (Plan 3 / migration 000045). Each row is a (org, tenant)
 * tuple; the user fields describe the *representative* user attached to
 * that row for display/audit, not the member identity itself.
 *
 * - `tenant_id` + `tenant_name` are the canonical member identity.
 * - `representative_user_id` is the post-Plan-3 explicit alias; `user_id`
 *   is kept for backward compatibility and points at the same value.
 * - Two users belonging to the *same* tenant produce a single row here
 *   (UNIQUE(org_id, tenant_id)); the rep is the user who first brought
 *   the tenant in.
 */
export interface OrganizationMember {
  id: string
  user_id: string
  representative_user_id?: string
  username: string
  email: string
  avatar?: string
  role: 'admin' | 'editor' | 'viewer'
  tenant_id: number
  tenant_name?: string
  joined_at: string
}

export interface KnowledgeBaseShare {
  id: string
  knowledge_base_id: string
  knowledge_base_name?: string
  knowledge_base_type?: string
  knowledge_count?: number
  chunk_count?: number
  organization_id: string
  organization_name?: string
  shared_by_user_id: string
  shared_by_username?: string
  source_tenant_id: number
  /** Share permission: what the space was granted (viewer/editor) */
  permission: 'admin' | 'editor' | 'viewer'
  /** Current user's role in this organization (admin/editor/viewer) */
  my_role_in_org?: 'admin' | 'editor' | 'viewer'
  /** Effective permission for current user = min(permission, my_role_in_org) */
  my_permission?: 'admin' | 'editor' | 'viewer'
  created_at: string
}

export interface SharedKnowledgeBase {
  knowledge_base: {
    id: string
    name: string
    description: string
    type: string
    knowledge_count?: number
    chunk_count?: number
    created_at?: string
    updated_at?: string
  }
  share_id: string
  organization_id: string
  org_name: string
  permission: 'admin' | 'editor' | 'viewer'
  source_tenant_id: number
  shared_at: string
}

/** When set, this KB is visible in the space via a shared agent (read-only, no direct KB share) */
export interface SourceFromAgentInfo {
  agent_id: string
  agent_name: string
  /** "all" | "selected" | "none" — for showing agent's KB strategy in the drawer */
  kb_selection_mode?: string
}

/** Item from GET /organizations/:id/shared-knowledge-bases (space-scoped list including mine and agent-carried) */
export type OrganizationSharedKnowledgeBaseItem = SharedKnowledgeBase & {
  is_mine: boolean
  /** Present when the KB is from a shared agent's config (not directly shared to the space) */
  source_from_agent?: SourceFromAgentInfo
}

export interface OrganizationPreview {
  id: string
  name: string
  description: string
  avatar?: string
  member_count: number
  share_count: number
  agent_share_count?: number
  is_already_member: boolean
  require_approval: boolean
  created_at: string
}

/** Searchable (discoverable) organization item for join flow */
export interface SearchableOrganizationItem {
  id: string
  name: string
  description: string
  avatar?: string
  member_count: number
  member_limit: number // 0 = unlimited
  share_count: number
  agent_share_count?: number
  is_already_member: boolean
  require_approval: boolean
}

// Request types
export interface CreateOrganizationRequest {
  name: string
  description?: string
  avatar?: string
  invite_code_validity_days?: number // 0=never, 1, 7, 30; default 7
  member_limit?: number // 0=unlimited; default 50
}

export interface UpdateOrganizationRequest {
  name?: string
  description?: string
  avatar?: string
  require_approval?: boolean
  searchable?: boolean
  invite_code_validity_days?: number // 0=never, 1, 7, 30
  member_limit?: number // 0=unlimited
}

export interface UpdateMemberRoleRequest {
  role: 'admin' | 'editor' | 'viewer'
}

export interface JoinOrganizationRequest {
  invite_code: string
}

export interface ShareKnowledgeBaseRequest {
  organization_id: string
  permission: 'admin' | 'editor' | 'viewer'
}

export interface UpdateSharePermissionRequest {
  permission: 'admin' | 'editor' | 'viewer'
}

// Response types
export interface ApiResponse<T> {
  success: boolean
  data?: T
  message?: string
}

/** Per-org resource counts (included in list my organizations to avoid extra GET /me/resource-counts) */
export interface ResourceCountsByOrg {
  knowledge_bases: { by_organization: Record<string, number> }
  agents: { by_organization: Record<string, number> }
}

export interface ListOrganizationsResponse {
  organizations: Organization[]
  total: number
  resource_counts?: ResourceCountsByOrg
}

export interface ListMembersResponse {
  members: OrganizationMember[]
  total: number
}

export interface JoinRequestResponse {
  id: string
  user_id: string
  username: string
  email: string
  message: string
  request_type: 'join' | 'upgrade' // 'join' for new member, 'upgrade' for role upgrade
  prev_role?: string // Previous role (only for upgrade requests)
  requested_role: string // Role applicant requested: admin, editor, viewer
  status: string
  created_at: string
  reviewed_at?: string
}

export interface ListJoinRequestsResponse {
  requests: JoinRequestResponse[]
  total: number
}

export interface SubmitJoinRequestRequest {
  invite_code: string
  message?: string
  role?: 'admin' | 'editor' | 'viewer' // Optional: role applicant requests; default viewer
}

export interface ReviewJoinRequestRequest {
  approved: boolean
  message?: string
  role?: 'admin' | 'editor' | 'viewer' // Optional: role to assign when approving; overrides applicant's requested role
}

export interface RequestRoleUpgradeRequest {
  requested_role: 'admin' | 'editor' | 'viewer' // The role user wants to upgrade to
  message?: string // Optional message explaining the reason
}

/**
 * InviteMemberRequest enrols a *tenant* into the organization (Plan 3).
 * - `tenant_id` is the preferred identity for the invitee.
 * - `representative_user_id` is optional metadata for the OTM row's
 *   display/audit; when omitted the server picks a sensible default.
 * - `user_id` is kept for backward compatibility with pre-Plan-3 callers
 *   (the server resolves the user's tenant if `tenant_id` is unset).
 */
export interface InviteMemberRequest {
  tenant_id?: number
  representative_user_id?: string
  user_id?: string
  role: 'admin' | 'editor' | 'viewer'
}

export interface UserSearchResult {
  id: string
  username: string
  email: string
  avatar?: string
}

/**
 * TenantInviteCandidate is one row in the search-tenants-for-invite picker.
 * The picker is tenant-centric; the representative_* fields describe the
 * user that caused the tenant to appear in the search (for display only).
 */
export interface TenantInviteCandidate {
  tenant_id: number
  tenant_name: string
  representative_user_id: string
  representative_username: string
  representative_email: string
  representative_avatar?: string
}

export interface ListSharesResponse {
  shares: KnowledgeBaseShare[]
  total: number
}

// Agent share types
export interface AgentShareResponse {
  id: string
  agent_id: string
  agent_name?: string
  organization_id: string
  organization_name?: string
  shared_by_user_id: string
  shared_by_username?: string
  source_tenant_id: number
  permission: string
  my_role_in_org?: string
  my_permission?: string
  created_at: string
  /** Agent scope summary for list display */
  scope_kb?: string
  scope_kb_count?: number
  scope_web_search?: boolean
  scope_mcp?: string
  scope_mcp_count?: number
  /** Agent avatar (emoji) for list display */
  agent_avatar?: string
}

export interface SharedAgentInfo {
  agent: { id: string; name: string; description?: string; [key: string]: any }
  share_id: string
  organization_id: string
  org_name: string
  permission: string
  source_tenant_id: number
  shared_at: string
  shared_by_user_id?: string
  shared_by_username?: string
  /** 由后端在源空间解析,不与当前空间的搜索引擎列表比较 */
  web_search_ready: boolean
  /** 当前用户是否已停用该共享智能体(仅影响本人对话下拉显示) */
  disabled_by_me?: boolean
}

/** Item from GET /organizations/:id/shared-agents (space-scoped list including mine) */
export type OrganizationSharedAgentItem = SharedAgentInfo & { is_mine: boolean }

export interface ListAgentSharesResponse {
  shares: AgentShareResponse[]
  total: number
}

// Organization API functions

/**
 * Create a new organization
 */
export async function createOrganization(req: CreateOrganizationRequest): Promise<ApiResponse<Organization>> {
  try {
    const response = await post('/api/v1/organizations', req)
    return response as unknown as ApiResponse<Organization>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to create organization' }
  }
}

/**
 * Get organization by ID
 */
export async function getOrganization(id: string): Promise<ApiResponse<Organization>> {
  try {
    const response = await get(`/api/v1/organizations/${id}`)
    return response as unknown as ApiResponse<Organization>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to get organization' }
  }
}

/**
 * List my organizations
 */
export async function listMyOrganizations(): Promise<ApiResponse<ListOrganizationsResponse>> {
  try {
    const response = await get('/api/v1/organizations')
    return response as unknown as ApiResponse<ListOrganizationsResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list organizations' }
  }
}

/**
 * Update organization
 */
export async function updateOrganization(id: string, req: UpdateOrganizationRequest): Promise<ApiResponse<Organization>> {
  try {
    const response = await put(`/api/v1/organizations/${id}`, req)
    return response as unknown as ApiResponse<Organization>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to update organization' }
  }
}

/**
 * Delete organization
 */
export async function deleteOrganization(id: string): Promise<ApiResponse<void>> {
  try {
    const response = await del(`/api/v1/organizations/${id}`)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to delete organization' }
  }
}

/**
 * Join organization by invite code
 */
export async function joinOrganization(req: JoinOrganizationRequest): Promise<ApiResponse<Organization>> {
  try {
    const response = await post('/api/v1/organizations/join', req)
    return response as unknown as ApiResponse<Organization>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to join organization' }
  }
}

/**
 * Submit a join request (for organizations that require approval).
 * Optional role: applicant's requested role (admin/editor/viewer); default viewer.
 */
export async function submitJoinRequest(req: SubmitJoinRequestRequest): Promise<ApiResponse<void>> {
  try {
    const response = await post('/api/v1/organizations/join-request', req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to submit join request' }
  }
}

/**
 * Preview organization by invite code (without joining)
 */
export async function previewOrganization(inviteCode: string): Promise<ApiResponse<OrganizationPreview>> {
  try {
    const response = await get(`/api/v1/organizations/preview/${inviteCode}`)
    return response as unknown as ApiResponse<OrganizationPreview>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to preview organization' }
  }
}

/**
 * Search searchable (discoverable) organizations
 */
export async function searchSearchableOrganizations(
  q: string = '',
  limit: number = 20
): Promise<ApiResponse<{ data: SearchableOrganizationItem[]; total: number }>> {
  try {
    const params = new URLSearchParams()
    if (q) params.set('q', q)
    params.set('limit', String(limit))
    const response = await get(`/api/v1/organizations/search?${params.toString()}`)
    const res = response as unknown as { success: boolean; data?: SearchableOrganizationItem[]; total?: number; message?: string }
    return {
      success: res.success,
      data: res.success ? { data: res.data || [], total: res.total ?? 0 } : undefined,
      message: res.message,
    }
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to search organizations' }
  }
}

/**
 * Join a searchable organization by ID (no invite code)
 */
export async function joinOrganizationById(
  organizationId: string,
  message?: string,
  role?: 'admin' | 'editor' | 'viewer'
): Promise<ApiResponse<Organization>> {
  try {
    const body: { organization_id: string; message?: string; role?: string } = { organization_id: organizationId }
    if (message) body.message = message
    if (role) body.role = role
    const response = await post('/api/v1/organizations/join-by-id', body)
    return response as unknown as ApiResponse<Organization>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to join organization' }
  }
}

/**
 * Leave organization
 */
export async function leaveOrganization(id: string): Promise<ApiResponse<void>> {
  try {
    const response = await post(`/api/v1/organizations/${id}/leave`, {})
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to leave organization' }
  }
}

/**
 * Request role upgrade in an organization
 */
export async function requestRoleUpgrade(
  orgId: string,
  request: RequestRoleUpgradeRequest
): Promise<ApiResponse<JoinRequestResponse>> {
  try {
    const response = await post(`/api/v1/organizations/${orgId}/request-upgrade`, request)
    return response as unknown as ApiResponse<JoinRequestResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to submit upgrade request' }
  }
}

/**
 * Generate new invite code
 */
export async function generateInviteCode(id: string): Promise<ApiResponse<{ invite_code: string }>> {
  try {
    const response = await post(`/api/v1/organizations/${id}/invite-code`, {})
    return response as unknown as ApiResponse<{ invite_code: string }>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to generate invite code' }
  }
}

// Member management

/**
 * List organization members
 */
export async function listMembers(orgId: string): Promise<ApiResponse<ListMembersResponse>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/members`)
    return response as unknown as ApiResponse<ListMembersResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list members' }
  }
}

/**
 * Update member role (member is identified by tenant_id)
 */
export async function updateMemberRole(orgId: string, tenantId: number, req: UpdateMemberRoleRequest): Promise<ApiResponse<void>> {
  try {
    const response = await put(`/api/v1/organizations/${orgId}/members/${tenantId}`, req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to update member role' }
  }
}

/**
 * Remove member (member is identified by tenant_id)
 */
export async function removeMember(orgId: string, tenantId: number): Promise<ApiResponse<void>> {
  try {
    const response = await del(`/api/v1/organizations/${orgId}/members/${tenantId}`)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to remove member' }
  }
}

/**
 * List join requests (pending) for an organization (admin only)
 */
export async function listJoinRequests(orgId: string): Promise<ApiResponse<ListJoinRequestsResponse>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/join-requests`)
    return response as unknown as ApiResponse<ListJoinRequestsResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list join requests' }
  }
}

/**
 * Review join request (approve or reject) - admin only
 */
export async function reviewJoinRequest(orgId: string, requestId: string, req: ReviewJoinRequestRequest): Promise<ApiResponse<void>> {
  try {
    const response = await put(`/api/v1/organizations/${orgId}/join-requests/${requestId}/review`, req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to review join request' }
  }
}

// Knowledge base sharing

/**
 * Share knowledge base to organization
 */
export async function shareKnowledgeBase(kbId: string, req: ShareKnowledgeBaseRequest): Promise<ApiResponse<KnowledgeBaseShare>> {
  try {
    const response = await post(`/api/v1/knowledge-bases/${kbId}/shares`, req)
    return response as unknown as ApiResponse<KnowledgeBaseShare>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to share knowledge base' }
  }
}

/**
 * List shares for a knowledge base
 */
export async function listKBShares(kbId: string): Promise<ApiResponse<ListSharesResponse>> {
  try {
    const response = await get(`/api/v1/knowledge-bases/${kbId}/shares`)
    return response as unknown as ApiResponse<ListSharesResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list shares' }
  }
}

/**
 * Update share permission
 */
export async function updateSharePermission(kbId: string, shareId: string, req: UpdateSharePermissionRequest): Promise<ApiResponse<void>> {
  try {
    const response = await put(`/api/v1/knowledge-bases/${kbId}/shares/${shareId}`, req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to update share permission' }
  }
}

/**
 * Remove share
 */
export async function removeShare(kbId: string, shareId: string): Promise<ApiResponse<void>> {
  try {
    const response = await del(`/api/v1/knowledge-bases/${kbId}/shares/${shareId}`)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to remove share' }
  }
}

/**
 * List shared knowledge bases (shared to me through organizations)
 */
export async function listSharedKnowledgeBases(): Promise<ApiResponse<SharedKnowledgeBase[]>> {
  try {
    const response = await get('/api/v1/shared-knowledge-bases')
    return response as unknown as ApiResponse<SharedKnowledgeBase[]>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list shared knowledge bases' }
  }
}

/**
 * List all knowledge bases in an organization (including those shared by current tenant), for list page when a space is selected.
 */
export async function listOrganizationSharedKnowledgeBases(orgId: string): Promise<ApiResponse<OrganizationSharedKnowledgeBaseItem[]>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/shared-knowledge-bases`)
    return response as unknown as ApiResponse<OrganizationSharedKnowledgeBaseItem[]>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list organization shared knowledge bases' }
  }
}

/**
 * List knowledge bases shared to a specific organization
 */
export async function listOrgShares(orgId: string): Promise<ApiResponse<ListSharesResponse>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/shares`)
    return response as unknown as ApiResponse<ListSharesResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list organization shares' }
  }
}

// Agent sharing
export async function shareAgent(agentId: string, req: ShareKnowledgeBaseRequest): Promise<ApiResponse<AgentShareResponse>> {
  try {
    const response = await post(`/api/v1/agents/${agentId}/shares`, req)
    return response as unknown as ApiResponse<AgentShareResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to share agent' }
  }
}

export async function listAgentShares(agentId: string): Promise<ApiResponse<ListAgentSharesResponse>> {
  try {
    const response = await get(`/api/v1/agents/${agentId}/shares`)
    return response as unknown as ApiResponse<ListAgentSharesResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list agent shares' }
  }
}

export async function updateAgentSharePermission(agentId: string, shareId: string, req: UpdateSharePermissionRequest): Promise<ApiResponse<void>> {
  try {
    const response = await put(`/api/v1/agents/${agentId}/shares/${shareId}`, req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to update share permission' }
  }
}

export async function removeAgentShare(agentId: string, shareId: string): Promise<ApiResponse<void>> {
  try {
    const response = await del(`/api/v1/agents/${agentId}/shares/${shareId}`)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to remove share' }
  }
}

export async function listSharedAgents(): Promise<ApiResponse<SharedAgentInfo[]>> {
  try {
    const response = await get('/api/v1/shared-agents')
    return response as unknown as ApiResponse<SharedAgentInfo[]>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list shared agents' }
  }
}

/**
 * List all agents in an organization (including those shared by current tenant), for list page when a space is selected.
 */
export async function listOrganizationSharedAgents(orgId: string): Promise<ApiResponse<OrganizationSharedAgentItem[]>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/shared-agents`)
    return response as unknown as ApiResponse<OrganizationSharedAgentItem[]>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list organization shared agents' }
  }
}

/** 设置当前用户对某共享智能体的停用状态(仅影响本人对话下拉显示) */
export async function setSharedAgentDisabledByMe(
  agentId: string,
  disabled: boolean
): Promise<ApiResponse<void>> {
  try {
    const response = await post('/api/v1/shared-agents/disabled', {
      agent_id: agentId,
      disabled
    })
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to update preference' }
  }
}

export async function listOrgAgentShares(orgId: string): Promise<ApiResponse<ListAgentSharesResponse>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/agent-shares`)
    return response as unknown as ApiResponse<ListAgentSharesResponse>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to list organization agent shares' }
  }
}

/**
 * Search candidate tenants for inviting to organization (excludes tenants
 * already in the org). The endpoint resolves one exact workspace ID; it does not expose
 * global workspace-name, username, or email search.
 */
export async function searchTenantsForInvite(
  orgId: string,
  query: string,
  limit: number = 10
): Promise<ApiResponse<TenantInviteCandidate[]>> {
  try {
    const response = await get(`/api/v1/organizations/${orgId}/search-tenants?q=${encodeURIComponent(query)}&limit=${limit}`)
    return response as unknown as ApiResponse<TenantInviteCandidate[]>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to search tenants' }
  }
}

/**
 * @deprecated Use `searchTenantsForInvite`. Kept for callers that haven't
 * migrated yet; the backend serves the tenant-grouped shape from the
 * legacy `/search-users` path as well.
 */
export async function searchUsersForInvite(
  orgId: string,
  query: string,
  limit: number = 10
): Promise<ApiResponse<TenantInviteCandidate[]>> {
  return searchTenantsForInvite(orgId, query, limit)
}

/**
 * Invite a user to organization directly (admin only)
 */
export async function inviteMember(
  orgId: string,
  req: InviteMemberRequest
): Promise<ApiResponse<void>> {
  try {
    const response = await post(`/api/v1/organizations/${orgId}/invite`, req)
    return response as unknown as ApiResponse<void>
  } catch (error: any) {
    return { success: false, message: error.message || 'Failed to invite member' }
  }
}