@morscherlab/mint-sdk 1.2.0-beta.1 → 1.2.0-beta.3

package/src/composables/useAnalysisArtifacts.ts

@@ -1,361 +0,0 @@
-import {
-  computed,
-  ref,
-  toValue,
-  watch,
-  type ComputedRef,
-  type MaybeRefOrGetter,
-  type Ref,
-} from 'vue'
-import { useApi } from './useApi'
-import { useRequestSyncState } from './useRequestSyncState'
-import {
-  getInjectedPlatformContext,
-  resolveCurrentExperimentId,
-} from './platformContextHelpers'
-import type {
-  AnalysisArtifactDetail,
-  AnalysisArtifactListResponse,
-  AnalysisArtifactMetadataUpdate,
-  AnalysisArtifactStatusFilter,
-  AnalysisArtifactSummary,
-  AnalysisArtifactTarget,
-} from '../types/analysisArtifactTypes'
-
-export { ANALYSIS_FILE_ARTIFACT_SCHEMA } from '../types/analysisArtifactTypes'
-
-export interface UseAnalysisArtifactsOptions {
-  /** Experiment id; defaults to platform injection or URL. Refetches when it changes. */
-  experimentId?: MaybeRefOrGetter<number | undefined>
-  /** Override API base URL. */
-  apiBaseUrl?: string
-  /** Scope to a single owning plugin; omit or null to keep all plugins. */
-  pluginId?: MaybeRefOrGetter<string | null | undefined>
-  /** Always request archived artifacts alongside active ones. */
-  includeArchived?: MaybeRefOrGetter<boolean | undefined>
-  /** Fetch as soon as an experiment id is available. */
-  immediate?: boolean
-}
-
-export interface UseAnalysisArtifactsReturn {
-  /** Fetched artifacts, scoped to pluginId when set. */
-  artifacts: ComputedRef<AnalysisArtifactSummary[]>
-  /** Artifacts after applying statusFilter, pluginFilter, and search. */
-  visibleArtifacts: ComputedRef<AnalysisArtifactSummary[]>
-  /** Detail loaded by the last successful getDetail call, or null. */
-  selectedDetail: Ref<AnalysisArtifactDetail | null>
-  /** Resolved experiment id from options, platform injection, or URL. */
-  currentExperimentId: ComputedRef<number | undefined>
-  /** Whether an experiment id is available. */
-  hasCurrentExperiment: ComputedRef<boolean>
-  /** Whether any list or detail fetch is in progress. */
-  isLoading: ComputedRef<boolean>
-  /** Whether any archive/restore/metadata mutation is in progress. */
-  isMutating: ComputedRef<boolean>
-  /** Error message from the last failed operation, or null. */
-  error: Ref<string | null>
-  /** Timestamp of the last successful load, or null. */
-  lastLoadedAt: Ref<Date | null>
-  /** Case-insensitive filter over display_name and artifact_key. */
-  search: Ref<string>
-  /** Lifecycle filter; widening past "active" refetches with include_archived. */
-  statusFilter: Ref<AnalysisArtifactStatusFilter>
-  /** Plugin filter applied to visibleArtifacts, or null for all plugins. */
-  pluginFilter: Ref<string | null>
-  /** Fetch the artifact list for the current experiment. */
-  list: () => Promise<AnalysisArtifactSummary[]>
-  /** Alias of list. */
-  refresh: () => Promise<AnalysisArtifactSummary[]>
-  /** Fetch one artifact with its result payload; null when it fails or is superseded. */
-  getDetail: (artifactId: number) => Promise<AnalysisArtifactDetail | null>
-  /** Resolve and fetch the exact stable artifact identity. */
-  resolveTarget: (target: AnalysisArtifactTarget) => Promise<AnalysisArtifactDetail | null>
-  /** Update display_name and/or note; resolves to the updated summary or null. */
-  updateMetadata: (
-    artifactId: number,
-    updates: AnalysisArtifactMetadataUpdate,
-  ) => Promise<AnalysisArtifactSummary | null>
-  /** Archive an artifact; resolves to the updated summary or null. */
-  archive: (artifactId: number) => Promise<AnalysisArtifactSummary | null>
-  /** Restore an archived artifact; resolves to the updated summary or null. */
-  restore: (artifactId: number) => Promise<AnalysisArtifactSummary | null>
-  /** Whether a key exists in the loaded artifacts (no network call). */
-  hasArtifactKey: (artifactKey: string) => boolean
-  /** Reset artifacts, selection, and error. */
-  clear: () => void
-}
-
-/**
- * Lists and manages analysis artifacts through the user-facing platform API.
- *
- * @example Recommended
- * ```ts
- * const artifacts = useAnalysisArtifacts({ pluginId: 'LEAF' })
- * await artifacts.list()
- * ```
- */
-export function useAnalysisArtifacts(
-  options: UseAnalysisArtifactsOptions = {},
-): UseAnalysisArtifactsReturn {
-  const injectedContext = getInjectedPlatformContext()
-  const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl })
-
-  const currentExperimentId = computed<number | undefined>(
-    () => toValue(options.experimentId) ?? resolveCurrentExperimentId(injectedContext),
-  )
-  const hasCurrentExperiment = computed(() => currentExperimentId.value !== undefined)
-  const scopePluginId = computed(() => toValue(options.pluginId) ?? null)
-
-  const request = useRequestSyncState('Analysis artifact request failed.')
-  const fetchedArtifacts = ref<AnalysisArtifactSummary[]>([])
-  const selectedDetail = ref<AnalysisArtifactDetail | null>(null)
-
-  // Counters, not booleans: overlapping requests must not clear each other's flag.
-  const loadingCount = ref(0)
-  const mutatingCount = ref(0)
-  const isLoading = computed(() => loadingCount.value > 0)
-  const isMutating = computed(() => mutatingCount.value > 0)
-
-  const search = ref('')
-  const statusFilter = ref<AnalysisArtifactStatusFilter>('active')
-  const pluginFilter = ref<string | null>(null)
-
-  const needsArchived = computed(
-    () => Boolean(toValue(options.includeArchived)) || statusFilter.value !== 'active',
-  )
-
-  const artifacts = computed(() => (
-    scopePluginId.value
-      ? fetchedArtifacts.value.filter((artifact) => artifact.plugin_id === scopePluginId.value)
-      : fetchedArtifacts.value
-  ))
-
-  const visibleArtifacts = computed(() => {
-    const query = search.value.trim().toLowerCase()
-    return artifacts.value.filter((artifact) => {
-      if (statusFilter.value !== 'all' && artifact.status !== statusFilter.value) return false
-      if (pluginFilter.value && artifact.plugin_id !== pluginFilter.value) return false
-      if (!query) return true
-      return (
-        artifact.display_name.toLowerCase().includes(query)
-        || artifact.artifact_key.toLowerCase().includes(query)
-      )
-    })
-  })
-
-  // Generation tokens: a superseded response must commit nothing — not rows, not the
-  // shared error, not lastLoadedAt — or a late failure would bury fresh results.
-  let listToken = 0
-  let detailToken = 0
-  const hasRequestedList = ref(false)
-
-  function currentExperimentIdOrError(action: string): number | undefined {
-    const id = currentExperimentId.value
-    if (id === undefined) {
-      request.setError(`No current experiment is selected for ${action}`)
-      return undefined
-    }
-    return id
-  }
-
-  function replaceArtifact(summary: AnalysisArtifactSummary): void {
-    const index = fetchedArtifacts.value.findIndex((artifact) => artifact.id === summary.id)
-    if (index >= 0) {
-      fetchedArtifacts.value.splice(index, 1, summary)
-    }
-  }
-
-  async function list(): Promise<AnalysisArtifactSummary[]> {
-    const experimentId = currentExperimentIdOrError('listing analysis artifacts')
-    if (experimentId === undefined) {
-      fetchedArtifacts.value = []
-      return []
-    }
-    const token = ++listToken
-    hasRequestedList.value = true
-    loadingCount.value += 1
-    request.clearError()
-    try {
-      const data = await api.get<AnalysisArtifactListResponse>(
-        `/experiments/${experimentId}/analysis-artifacts?include_archived=${needsArchived.value}`,
-      )
-      if (token !== listToken) return artifacts.value
-      // Copy: replaceArtifact splices in place, and the response array is not ours.
-      fetchedArtifacts.value = [...(data?.artifacts ?? [])]
-      request.markLoaded()
-      return artifacts.value
-    } catch (err) {
-      if (token !== listToken) return []
-      request.setError(err)
-      fetchedArtifacts.value = []
-      return []
-    } finally {
-      loadingCount.value -= 1
-    }
-  }
-
-  async function getDetail(artifactId: number): Promise<AnalysisArtifactDetail | null> {
-    const experimentId = currentExperimentIdOrError('loading an analysis artifact')
-    if (experimentId === undefined) return null
-    const token = ++detailToken
-    loadingCount.value += 1
-    request.clearError()
-    try {
-      const detail = await api.get<AnalysisArtifactDetail>(
-        `/experiments/${experimentId}/analysis-artifacts/${artifactId}`,
-      )
-      if (token !== detailToken) return null
-      selectedDetail.value = detail
-      request.markLoaded()
-      return detail
-    } catch (err) {
-      if (token !== detailToken) return null
-      request.setError(err)
-      return null
-    } finally {
-      loadingCount.value -= 1
-    }
-  }
-
-  async function resolveTarget(
-    target: AnalysisArtifactTarget,
-  ): Promise<AnalysisArtifactDetail | null> {
-    const experimentId = currentExperimentId.value
-    if (experimentId !== target.experimentId) {
-      request.setError(
-        `Analysis artifact target belongs to experiment ${target.experimentId}, not `
-        + `${experimentId ?? 'the current selection'}.`,
-      )
-      return null
-    }
-
-    const available = await list()
-    const summary = available.find((artifact) => (
-      artifact.plugin_id === target.artifactPluginId
-      && artifact.artifact_key === target.artifactKey
-      && artifact.status === 'active'
-    ))
-    if (!summary) {
-      request.setError(
-        `Analysis artifact ${target.artifactPluginId}/${target.artifactKey} is not available.`,
-      )
-      return null
-    }
-
-    const detail = await getDetail(summary.id)
-    if (
-      detail
-      && (
-        detail.experiment_id !== target.experimentId
-        || detail.plugin_id !== target.artifactPluginId
-        || detail.artifact_key !== target.artifactKey
-      )
-    ) {
-      selectedDetail.value = null
-      request.setError(
-        `Analysis artifact ${target.artifactPluginId}/${target.artifactKey} did not `
-        + 'match the requested identity.',
-      )
-      return null
-    }
-    return detail
-  }
-
-  async function mutate(
-    action: string,
-    operation: (experimentId: number) => Promise<AnalysisArtifactSummary>,
-  ): Promise<AnalysisArtifactSummary | null> {
-    const experimentId = currentExperimentIdOrError(action)
-    if (experimentId === undefined) return null
-    mutatingCount.value += 1
-    request.clearError()
-    try {
-      const summary = await operation(experimentId)
-      replaceArtifact(summary)
-      request.markSaved()
-      return summary
-    } catch (err) {
-      request.setError(err)
-      return null
-    } finally {
-      mutatingCount.value -= 1
-    }
-  }
-
-  async function updateMetadata(
-    artifactId: number,
-    updates: AnalysisArtifactMetadataUpdate,
-  ): Promise<AnalysisArtifactSummary | null> {
-    return mutate('updating artifact metadata', (experimentId) =>
-      api.patch<AnalysisArtifactSummary>(
-        `/experiments/${experimentId}/analysis-artifacts/${artifactId}`,
-        updates,
-      ))
-  }
-
-  async function archive(artifactId: number): Promise<AnalysisArtifactSummary | null> {
-    return mutate('archiving an analysis artifact', (experimentId) =>
-      api.post<AnalysisArtifactSummary>(
-        `/experiments/${experimentId}/analysis-artifacts/${artifactId}/archive`,
-      ))
-  }
-
-  async function restore(artifactId: number): Promise<AnalysisArtifactSummary | null> {
-    return mutate('restoring an analysis artifact', (experimentId) =>
-      api.post<AnalysisArtifactSummary>(
-        `/experiments/${experimentId}/analysis-artifacts/${artifactId}/restore`,
-      ))
-  }
-
-  function hasArtifactKey(artifactKey: string): boolean {
-    return artifacts.value.some((artifact) => artifact.artifact_key === artifactKey)
-  }
-
-  /** Drop experiment-scoped state and orphan every in-flight response. */
-  function clear(): void {
-    listToken += 1
-    detailToken += 1
-    fetchedArtifacts.value = []
-    selectedDetail.value = null
-    request.clearError()
-  }
-
-  // Refetch when the scope changes or archived rows are newly needed. `immediate`
-  // covers a late-resolving experiment id; otherwise stay quiet until something
-  // has asked for a list at least once.
-  watch([currentExperimentId, needsArchived], ([experimentId], [previousExperimentId]) => {
-    if (experimentId !== previousExperimentId) {
-      // Scope changed: the previous experiment's rows and any in-flight reply for
-      // them must not survive into the new one.
-      clear()
-    }
-    if (experimentId === undefined) return
-    if (options.immediate || hasRequestedList.value) {
-      void list()
-    }
-  }, { immediate: options.immediate })
-
-  return {
-    artifacts,
-    visibleArtifacts,
-    selectedDetail,
-    currentExperimentId,
-    hasCurrentExperiment,
-    isLoading,
-    isMutating,
-    error: request.error,
-    lastLoadedAt: request.lastLoadedAt,
-    search,
-    statusFilter,
-    pluginFilter,
-    list,
-    refresh: list,
-    getDetail,
-    resolveTarget,
-    updateMetadata,
-    archive,
-    restore,
-    hasArtifactKey,
-    clear,
-  }
-}

package/src/composables/useApi.ts

@@ -1,319 +0,0 @@
-import axios, { type AxiosInstance, type AxiosRequestConfig, type InternalAxiosRequestConfig } from 'axios'
-import { useSettingsStore } from '../stores/settings'
-import { useAuthStore } from '../stores/auth'
-
-let apiClientInstance: AxiosInstance | null = null
-let interceptorAttached = false
-
-interface MintAxiosRequestConfig extends AxiosRequestConfig {
-  _mintSkipAuth?: boolean
-  _mintAuthToken?: string
-}
-
-interface MintInternalAxiosRequestConfig extends InternalAxiosRequestConfig {
-  _mintSkipAuth?: boolean
-  _mintAuthToken?: string
-}
-
-type MutableHeaders = Record<string, unknown> & {
-  has?: (header: string) => boolean
-  set?: (header: string, value: string) => void
-  delete?: (header: string) => void
-}
-
-function joinUrlPath(baseUrl: string, path: string): string {
-  if (/^https?:\/\//i.test(path)) return path
-  if (!path) return baseUrl
-  if (path.startsWith('?') || path.startsWith('#')) return `${baseUrl.replace(/\/+$/, '')}${path}`
-  const normalizedBase = baseUrl.replace(/\/+$/, '')
-  const normalizedPath = path.replace(/^\/+/, '/')
-  return `${normalizedBase}${normalizedPath.startsWith('/') ? normalizedPath : `/${normalizedPath}`}`
-}
-
-function getBasePath(baseUrl: string): string {
-  if (!baseUrl) return '/'
-
-  try {
-    const origin = typeof window !== 'undefined' ? window.location.origin : 'http://localhost'
-    return new URL(baseUrl, origin).pathname.replace(/\/+$/, '') || '/'
-  } catch {
-    const path = baseUrl.replace(/^https?:\/\/[^/]+/i, '')
-    return path.replace(/\/+$/, '') || '/'
-  }
-}
-
-function normalizeRequestUrl(baseUrl: string, url: string): string {
-  if (!url || /^https?:\/\//.test(url)) return url
-
-  const basePath = getBasePath(baseUrl)
-  if (basePath === '/') return url
-
-  const normalizedUrl = url.startsWith('/') ? url : `/${url}`
-  if (
-    normalizedUrl === basePath
-    || normalizedUrl.startsWith(`${basePath}?`)
-    || normalizedUrl.startsWith(`${basePath}#`)
-  ) {
-    return normalizedUrl.slice(basePath.length)
-  }
-  if (normalizedUrl.startsWith(`${basePath}/`)) {
-    return normalizedUrl.slice(basePath.length) || ''
-  }
-  return url
-}
-
-function asMutableHeaders(headers: AxiosRequestConfig['headers']): MutableHeaders | null {
-  return headers ? (headers as MutableHeaders) : null
-}
-
-function hasAuthorizationHeader(headers: AxiosRequestConfig['headers']): boolean {
-  const bag = asMutableHeaders(headers)
-  if (!bag) return false
-  if (typeof bag.has === 'function') return bag.has('Authorization')
-  return Object.keys(bag).some((key) => key.toLowerCase() === 'authorization')
-}
-
-function setAuthorizationHeader(headers: AxiosRequestConfig['headers'], value: string): void {
-  const bag = asMutableHeaders(headers)
-  if (!bag) return
-  if (typeof bag.set === 'function') {
-    bag.set('Authorization', value)
-    return
-  }
-  bag.Authorization = value
-}
-
-function deleteAuthorizationHeader(headers: AxiosRequestConfig['headers']): void {
-  const bag = asMutableHeaders(headers)
-  if (!bag) return
-  if (typeof bag.delete === 'function') {
-    bag.delete('Authorization')
-    return
-  }
-  for (const key of Object.keys(bag)) {
-    if (key.toLowerCase() === 'authorization') delete bag[key]
-  }
-}
-
-function getAuthorizationHeader(headers: AxiosRequestConfig['headers']): unknown {
-  const bag = asMutableHeaders(headers) as (MutableHeaders & { get?: (header: string) => unknown }) | null
-  if (!bag) return undefined
-  if (typeof bag.get === 'function') return bag.get('Authorization')
-  const key = Object.keys(bag).find((candidate) => candidate.toLowerCase() === 'authorization')
-  return key ? bag[key] : undefined
-}
-
-/** Raised when an authenticated SDK request is rejected because the login is no longer valid. */
-export class AuthenticationRequiredError extends Error {
-  readonly code = 'AUTHENTICATION_REQUIRED'
-  readonly status = 401
-
-  constructor(readonly cause?: unknown) {
-    super('Authentication required. Please sign in again.')
-    this.name = 'AuthenticationRequiredError'
-  }
-}
-
-/** @internal Convert a rejected authenticated request into the SDK's public auth error. */
-export function authenticationRequiredError(
-  cause: unknown,
-  rejectedToken?: string,
-): AuthenticationRequiredError {
-  const currentAuthStore = useAuthStore()
-  if (rejectedToken && currentAuthStore.token === rejectedToken) {
-    currentAuthStore.clearToken()
-  }
-  return new AuthenticationRequiredError(cause)
-}
-
-function getApiClient(): AxiosInstance {
-  if (!apiClientInstance) {
-    apiClientInstance = axios.create({
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    })
-  }
-  return apiClientInstance
-}
-
-export interface ApiClientOptions {
-  baseUrl?: string
-  timeout?: number
-  withAuth?: boolean
-}
-
-export interface UseApiReturn {
-  client: AxiosInstance
-  get: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>
-  post: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>
-  put: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>
-  patch: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>
-  delete: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>
-  upload: <T>(url: string, file: File, fieldName?: string, additionalData?: Record<string, unknown>) => Promise<T>
-  download: (url: string, filename?: string) => Promise<string>
-  buildUrl: (path: string) => string
-  buildWsUrl: (path: string) => string
-}
-
-/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. */
-export function useApi(options: ApiClientOptions = {}): UseApiReturn {
-  const settingsStore = useSettingsStore()
-  const authStore = useAuthStore()
-  const apiClient = getApiClient()
-
-  // Ensure auth store is initialized (reads token from localStorage)
-  if (!authStore.isInitialized) {
-    authStore.initialize()
-  }
-
-  // Attach auth interceptor only once (reads token dynamically, not from closure)
-  if (!interceptorAttached) {
-    apiClient.interceptors.request.use((config) => {
-      const request = config as MintInternalAxiosRequestConfig
-      if (request._mintSkipAuth) {
-        deleteAuthorizationHeader(request.headers)
-        return request
-      }
-
-      const currentAuthStore = useAuthStore()
-      if (currentAuthStore.token && config.headers && !hasAuthorizationHeader(config.headers)) {
-        setAuthorizationHeader(config.headers, `Bearer ${currentAuthStore.token}`)
-      }
-      if (getAuthorizationHeader(config.headers) === `Bearer ${currentAuthStore.token}`) {
-        request._mintAuthToken = currentAuthStore.token ?? undefined
-      }
-      return config
-    })
-    apiClient.interceptors.response.use(
-      (response) => response,
-      (error: unknown) => {
-        if (axios.isAxiosError(error) && error.response?.status === 401) {
-          const request = error.config as MintInternalAxiosRequestConfig | undefined
-          if (request?._mintSkipAuth !== true) {
-            return Promise.reject(authenticationRequiredError(error, request?._mintAuthToken))
-          }
-        }
-        return Promise.reject(error)
-      },
-    )
-    interceptorAttached = true
-  }
-
-  function getBaseUrl(): string {
-    return options.baseUrl ?? settingsStore.getApiBaseUrl()
-  }
-
-  function normalizeUrl(url: string): string {
-    return normalizeRequestUrl(getBaseUrl(), url)
-  }
-
-  // Build per-request config that applies this caller's options
-  function requestConfig(config?: AxiosRequestConfig): MintAxiosRequestConfig {
-    const base: MintAxiosRequestConfig = {
-      baseURL: getBaseUrl(),
-      timeout: options.timeout ?? settingsStore.requestTimeout,
-      ...config,
-    }
-    // Strip auth header if explicitly disabled
-    if (options.withAuth === false) {
-      base._mintSkipAuth = true
-      deleteAuthorizationHeader(base.headers)
-    }
-    return base
-  }
-
-  // Generic request methods
-  async function get<T>(url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.get<T>(normalizeUrl(url), requestConfig(config))
-    return response.data
-  }
-
-  async function post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.post<T>(normalizeUrl(url), data, requestConfig(config))
-    return response.data
-  }
-
-  async function put<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.put<T>(normalizeUrl(url), data, requestConfig(config))
-    return response.data
-  }
-
-  async function patch<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.patch<T>(normalizeUrl(url), data, requestConfig(config))
-    return response.data
-  }
-
-  async function del<T>(url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.delete<T>(normalizeUrl(url), requestConfig(config))
-    return response.data
-  }
-
-  // File upload helper
-  async function upload<T>(url: string, file: File, fieldName = 'file', additionalData?: Record<string, unknown>): Promise<T> {
-    const formData = new FormData()
-    formData.append(fieldName, file)
-
-    if (additionalData) {
-      Object.entries(additionalData).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          formData.append(key, typeof value === 'object' ? JSON.stringify(value) : String(value))
-        }
-      })
-    }
-
-    const response = await apiClient.post<T>(normalizeUrl(url), formData, requestConfig({
-      // Let Axios set Content-Type with the correct multipart boundary
-      headers: { 'Content-Type': undefined },
-    }))
-    return response.data
-  }
-
-  // Download helper - returns blob URL
-  async function download(url: string, filename?: string): Promise<string> {
-    const response = await apiClient.get(normalizeUrl(url), requestConfig({ responseType: 'blob' }))
-    const blob = new Blob([response.data])
-    const blobUrl = URL.createObjectURL(blob)
-
-    // Optionally trigger download
-    if (filename) {
-      const link = document.createElement('a')
-      link.href = blobUrl
-      link.download = filename
-      document.body.appendChild(link)
-      link.click()
-      document.body.removeChild(link)
-      // Revoke after a short delay to allow download to start;
-      // return empty string since the URL will be invalidated
-      setTimeout(() => URL.revokeObjectURL(blobUrl), 100)
-      return ''
-    }
-
-    // Caller is responsible for revoking when no filename is provided
-    return blobUrl
-  }
-
-  // Build full URL for external use (e.g., <a href="...">)
-  function buildUrl(path: string): string {
-    const baseUrl = getBaseUrl()
-    return joinUrlPath(baseUrl, normalizeRequestUrl(baseUrl, path))
-  }
-
-  // WebSocket URL builder
-  function buildWsUrl(path: string): string {
-    return joinUrlPath(settingsStore.getWsBaseUrl(), path)
-  }
-
-  return {
-    client: apiClient,
-    get,
-    post,
-    put,
-    patch,
-    delete: del,
-    upload,
-    download,
-    buildUrl,
-    buildWsUrl,
-  }
-}