@morscherlab/mint-sdk 1.2.0-beta.9 → 1.2.1

package/src/composables/useGeneratedAnalysis.ts

@@ -14,6 +14,7 @@ import type {
 } from './useJobsStatusTray'
 import { useEventStream, type EventStreamMessage } from './useEventStream'
 import { isActiveJobStatus, normalizeJobState } from '../jobs'
+import { MintApiError, mintApiErrorFromResponse } from '../apiErrors'
 import type {
   GeneratedAnalysisJob,
   GeneratedAnalysisJobInput,
@@ -129,16 +130,6 @@ type PluginJobStreamData = GeneratedAnalysisJobInput | {
   jobs: GeneratedAnalysisJobInput[]
 }
 
-class GeneratedAnalysisRequestError extends Error {
-  constructor(
-    readonly status: number,
-    readonly detail: unknown,
-  ) {
-    super(typeof detail === 'string' ? detail : `Request failed (${status})`)
-    this.name = 'GeneratedAnalysisRequestError'
-  }
-}
-
 export function createGeneratedAnalysisTransport(
   options: GeneratedAnalysisTransportOptions = {},
 ): GeneratedAnalysisTransport {
@@ -838,7 +829,7 @@ function createPluginJobs(
     job: GeneratedAnalysisJob,
     cause: unknown,
   ): void {
-    if (cause instanceof GeneratedAnalysisRequestError) {
+    if (cause instanceof MintApiError) {
       if (cause.status === 404 || cause.status === 410) {
         discardCachedResult(job.job_id)
         jobs.value = jobs.value.map(candidate => (
@@ -1037,8 +1028,10 @@ function createPluginJobs(
       },
     })
     if (!response.ok) {
-      const payload = await response.json().catch(() => null) as { detail?: unknown } | null
-      throw new GeneratedAnalysisRequestError(response.status, payload?.detail)
+      const payload: unknown = await response.json().catch(() => null)
+      throw mintApiErrorFromResponse(response.status, payload, {
+        requestId: response.headers.get('X-Request-ID'),
+      })
     }
     return await response.json() as T
   }
@@ -1177,20 +1170,20 @@ function createGeneratedSessionStorage(candidate?: Storage): GeneratedSessionSto
 }
 
 function isSessionNotFoundError(error: unknown): boolean {
-  return error instanceof GeneratedAnalysisRequestError
+  return error instanceof MintApiError
     && error.status === 404
-    && error.detail === SESSION_NOT_FOUND_DETAIL
+    && (error.detail === SESSION_NOT_FOUND_DETAIL || error.message === SESSION_NOT_FOUND_DETAIL)
 }
 
 function isRetryableResultError(error: unknown): boolean {
-  return !(error instanceof GeneratedAnalysisRequestError)
+  return !(error instanceof MintApiError)
     || error.status === 409
     || error.status === 429
     || error.status >= 500
 }
 
 function isRetryableJobLookupError(error: unknown): boolean {
-  return !(error instanceof GeneratedAnalysisRequestError)
+  return !(error instanceof MintApiError)
     || error.status === 408
     || error.status === 429
     || error.status >= 500

package/src/composables/usePlatformFilePickerAdapter.ts

@@ -0,0 +1,104 @@
+import type { PickerAdapter, PickerNode, PickerRequest } from '../types/filePicker'
+import type { FileDirectoryListing, ServerMount } from '../types/fileBrowserTypes'
+import { useApi } from './useApi'
+import { getInjectedPlatformContext } from './platformContextHelpers'
+import { pickerFormat } from './filePicker/validation'
+
+/** Opaque picker identity; decode before passing a selection to a mount-scoped API. */
+export function encodePlatformPickerPath(mountId: string, path = ''): string {
+  return JSON.stringify([mountId, path])
+}
+export function decodePlatformPickerPath(path: string): { mountId: string; path: string } {
+  const decoded: unknown = JSON.parse(path)
+  if (
+    !Array.isArray(decoded) ||
+    decoded.length !== 2 ||
+    !decoded.every((item) => typeof item === 'string') ||
+    !decoded[0]
+  ) {
+    throw new Error('Invalid platform picker path.')
+  }
+  return { mountId: decoded[0], path: decoded[1] }
+}
+
+/** Adapt the authenticated MINT mount API without exposing absolute host paths. */
+export function usePlatformFilePickerAdapter(options: { apiBaseUrl?: string } = {}): PickerAdapter {
+  const api = useApi({
+    baseUrl: options.apiBaseUrl ?? getInjectedPlatformContext()?.platformApiUrl,
+  })
+  const mountLabels = new Map<string, string>()
+  async function listRoot(request?: PickerRequest): Promise<PickerNode[]> {
+    try {
+      const { mounts } = await api.get<{ mounts: ServerMount[] }>('/filesystem/mounts', {
+        signal: request?.signal,
+      })
+      return mounts.map((mount) => {
+        mountLabels.set(mount.id, mount.label)
+        return {
+          kind: 'folder',
+          path: encodePlatformPickerPath(mount.id),
+          name: mount.label,
+          parentPath: null,
+          parentName: 'Server mounts',
+          unavailableReason: mount.available === false ? 'This mount is offline.' : undefined,
+        }
+      })
+    } catch (cause) {
+      if ((cause as { response?: { status?: number } }).response?.status === 404) return []
+      throw cause
+    }
+  }
+  async function listChildren(path: string, request?: PickerRequest): Promise<PickerNode[]> {
+    const location = decodePlatformPickerPath(path)
+    const query = new URLSearchParams({ mount_id: location.mountId, path: location.path })
+    const listing = await api.get<FileDirectoryListing>(`/filesystem/browse?${query}`, {
+      signal: request?.signal,
+    })
+    if (listing.truncated)
+      throw new Error(
+        'This directory exceeds the server listing limit. Choose a smaller data directory.',
+      )
+    return (listing.entries ?? []).map(
+      (entry) =>
+        ({
+          kind: entry.kind === 'directory' ? 'folder' : 'file',
+          path: encodePlatformPickerPath(location.mountId, entry.path),
+          parentPath: path,
+          parentName: `${mountLabels.get(location.mountId) ?? location.mountId}${location.path ? ` / ${location.path}` : ''}`,
+          name: entry.name,
+          bytes: entry.size_bytes,
+          ...(entry.kind === 'directory'
+            ? { hasChildren: entry.child_count !== 0 }
+            : { format: pickerFormat(entry.name) }),
+        }) as PickerNode,
+    )
+  }
+  return {
+    listRoot,
+    listChildren,
+    async search(query, scope, request) {
+      const matches: PickerNode[] = []
+      const queue = [scope.path]
+      const visited = new Set<string>()
+      while (queue.length) {
+        request?.signal?.throwIfAborted()
+        const path = queue.shift()!
+        if (visited.has(path)) continue
+        visited.add(path)
+        if (visited.size > 500)
+          throw new Error(
+            'Search reached its folder limit. Search a smaller location or turn off Subfolders.',
+          )
+        const nodes = path ? await listChildren(path, request) : await listRoot(request)
+        for (const node of nodes) {
+          if (node.name.toLowerCase().includes(query.toLowerCase())) matches.push(node)
+          if (scope.recursive && node.kind === 'folder' && !node.unavailableReason)
+            queue.push(node.path)
+        }
+        if (matches.length > 10000)
+          throw new Error('Too many search results. Use a more specific search.')
+      }
+      return matches
+    },
+  }
+}

package/src/composables/usePluginClient.ts

@@ -423,6 +423,7 @@ export function createPluginClient<TClient extends object = GeneratedPluginClien
       const api = useApi({
         baseUrl: parts.baseUrl,
         withAuth: endpoint.requiresAuth !== false,
+        typedErrors: true,
       })
       const config = endpointRequestConfig(endpoint, parts.query, callOptions)
 
@@ -469,6 +470,7 @@ export async function uploadPluginEndpoint<TResponse = unknown>(
   const api = useApi({
     baseUrl: parts.baseUrl,
     withAuth: endpoint.requiresAuth !== false,
+    typedErrors: true,
   })
   const body = endpoint.hasBody
     ? requestBodyFromPayload(payload, parts.requestPayload, endpoint)
@@ -507,6 +509,7 @@ export async function downloadPluginEndpoint(
   const api = useApi({
     baseUrl: parts.baseUrl,
     withAuth: endpoint.requiresAuth !== false,
+    typedErrors: true,
   })
   const config = {
     ...(endpointRequestConfig(endpoint, parts.query, { signal: options.signal }) ?? {}),

package/src/composables/usePluginWorkspace.ts

@@ -167,7 +167,6 @@ export function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePlugi
     title: props.sidebarTitle,
     subtitle: props.sidebarSubtitle,
     badge: props.sidebarBadge,
-    variant: props.sidebarVariant ?? 'analysis',
     panels: props.panels ?? {},
     activeView: navigationState.resolvedActiveView.value,
     floating: false,
@@ -187,7 +186,7 @@ export function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePlugi
     formDisabled: props.formDisabled ?? false,
     formReadonly: props.formReadonly ?? false,
     formSize: props.formSize ?? 'sm',
-    collapsible: props.sidebarCollapsible,
+    collapsible: props.sidebarCollapsible ?? true,
     collapsed: props.sidebarCollapsed,
     defaultCollapsed: props.defaultSidebarCollapsed ?? false,
     collapsedWidth: props.sidebarCollapsedWidth ?? '3rem',

package/src/composables/useToast.ts

@@ -1,15 +1,31 @@
 import { ref } from 'vue'
-import type { Toast } from '../types'
+import type { Toast, ToastOptions } from '../types'
 
 const toasts = ref<Toast[]>([])
 let nextId = 0
 
 /** Reactive global toast queue with success/error/warning/info variants and auto-dismiss timers. */
 export function useToast() {
-  function show(message: string, type: Toast['type'] = 'success', duration = 3500) {
+  /** Push a structured toast. `progress: 'indeterminate'` is the in-progress form and never auto-dismisses. */
+  function push(options: ToastOptions): number {
     const id = nextId++
-    toasts.value.push({ id, message, type, duration })
-    setTimeout(() => dismiss(id), duration)
+    const duration = options.duration ?? 3500
+    toasts.value.push({
+      id,
+      type: 'success',
+      ...options,
+      message: options.message ?? options.title,
+      duration,
+      actions: options.actions?.slice(0, 2),
+    })
+    if (options.progress !== 'indeterminate') {
+      setTimeout(() => dismiss(id), duration)
+    }
+    return id
+  }
+
+  function show(message: string, type: Toast['type'] = 'success', duration = 3500) {
+    push({ title: message, type, duration })
   }
 
   function success(message: string, duration = 3500) {
@@ -36,5 +52,5 @@ export function useToast() {
     toasts.value = []
   }
 
-  return { toasts, show, success, error, warning, info, dismiss, clear }
+  return { toasts, push, show, success, error, warning, info, dismiss, clear }
 }

package/src/generated/schema.ts

@@ -38,8 +38,9 @@ export function generatedJobFormSchema(definition: GeneratedJobDefinition): Form
 export function generatedJobDefaults(definition: GeneratedJobDefinition): Record<string, unknown> {
   return Object.fromEntries(
     Object.entries(definition.input_schema.properties ?? {})
-      .filter(([, schema]) => hasOwnDefault(schema))
-      .map(([name, schema]) => [name, structuredClone(schema.default)]),
+      .map(([name, schema]) => [name, resolveGeneratedField(definition.input_schema, schema)] as const)
+      .filter(([, field]) => field.hasDefault)
+      .map(([name, field]) => [name, structuredClone(field.defaultValue)]),
   )
 }
 
@@ -51,7 +52,17 @@ export function normalizeGeneratedJobInput(
   for (const [name, value] of Object.entries(values)) {
     const field = definition.input_schema.properties?.[name]
     if (!field) continue
-    normalized[name] = value
+    const { schema, reference } = resolveGeneratedField(definition.input_schema, field)
+    if (reference !== 'path' && Array.isArray(value) && ['integer', 'number'].includes(String(schema.items?.type))) {
+      normalized[name] = value.map(item => {
+        const numeric = typeof item === 'string' && item.trim() !== '' ? Number(item) : item
+        return typeof numeric === 'number' && Number.isFinite(numeric) ? numeric : item
+      })
+    } else if (reference !== 'path' && Array.isArray(value) && schema.items?.type === 'boolean') {
+      normalized[name] = value.map(item => item === 'true' ? true : item === 'false' ? false : item)
+    } else {
+      normalized[name] = value === undefined && allowsNull(schema) ? null : value
+    }
   }
   return normalized
 }
@@ -63,7 +74,12 @@ function toFormField(
 ): FormFieldSchema {
   const { schema, reference } = resolved
   const validation: NonNullable<FormFieldSchema['validation']> = {}
-  if (required) validation.required = true
+  const allowsEmpty = schema.type === 'array' || (
+    schema.type === 'string' && reference !== 'path'
+    && !(schema.minLength && schema.minLength > 0)
+    && (!schema.enum || schema.enum.includes(''))
+  )
+  if (required && !allowsNull(schema) && !allowsEmpty) validation.required = true
   if (schema.minimum !== undefined) validation.min = schema.minimum
   if (schema.maximum !== undefined) validation.max = schema.maximum
   if (schema.minLength !== undefined) validation.minLength = schema.minLength
@@ -71,15 +87,37 @@ function toFormField(
 
   const props: Record<string, unknown> = {}
   if (schema.enum) props.options = [...schema.enum]
+  if (schema.type === 'integer') {
+    if (schema.exclusiveMinimum !== undefined) validation.min = Math.max(Number(validation.min ?? -Infinity), Math.floor(schema.exclusiveMinimum) + 1)
+    if (schema.exclusiveMaximum !== undefined) validation.max = Math.min(Number(validation.max ?? Infinity), Math.ceil(schema.exclusiveMaximum) - 1)
+    if (validation.min !== undefined) validation.min = Math.ceil(Number(validation.min))
+    if (validation.max !== undefined) validation.max = Math.floor(Number(validation.max))
+    if (schema.multipleOf && Number.isInteger(schema.multipleOf)) {
+      if (validation.min !== undefined) validation.min = Math.ceil(Number(validation.min) / schema.multipleOf) * schema.multipleOf
+      if (validation.max !== undefined) validation.max = Math.floor(Number(validation.max) / schema.multipleOf) * schema.multipleOf
+    }
+    props.step = 1
+  }
+  if (schema.type === 'integer' || schema.type === 'number') {
+    if (validation.min !== undefined) props.min = validation.min
+    if (validation.max !== undefined) props.max = validation.max
+    if (schema.multipleOf !== undefined) props.step = schema.multipleOf
+  }
+  if (schema.type === 'array' && reference !== 'path') {
+    if (schema.items?.enum) props.options = [...schema.items.enum]
+    else props.allowDuplicates = true
+  }
   if (reference === 'path' && schema.type === 'array') props.multiple = true
   return {
     name,
     label: schema.title || humanize(name),
     type: fieldType(schema, reference),
     defaultValue: resolved.hasDefault ? structuredClone(resolved.defaultValue) : undefined,
+    disabled: Object.prototype.hasOwnProperty.call(schema, 'const') || undefined,
     hint: schema.description,
     validation,
     props,
+    itemType: schema.items?.type === 'number' || schema.items?.type === 'integer' ? 'number' : undefined,
   }
 }
 
@@ -87,27 +125,24 @@ function resolveGeneratedField(
   root: GeneratedJsonSchema,
   field: GeneratedJsonSchema,
 ): ResolvedGeneratedField {
-  const hasDefault = hasOwnDefault(field)
   const candidate = field.anyOf?.find(item => item.type !== 'null')
     ?? field.allOf?.[0]
     ?? field
+  let schema = { ...candidate, ...field }
   if (candidate.$ref) {
     const referenceParts = candidate.$ref.split('/')
     const key = referenceParts[referenceParts.length - 1]
-    const schema = key ? root.$defs?.[key] : undefined
-    if (!schema) throw new Error(`Generated field reference is missing: ${candidate.$ref}`)
-    return {
-      schema: { ...schema, title: field.title ?? schema.title },
-      reference: field['x-mint-component'] ?? schema['x-mint-component'],
-      hasDefault,
-      defaultValue: field.default,
-    }
+    const referenced = key ? root.$defs?.[key] : undefined
+    if (!referenced) throw new Error(`Generated field reference is missing: ${candidate.$ref}`)
+    schema = { ...referenced, ...candidate, ...field }
   }
+  if (schema.items) schema.items = resolveGeneratedField(root, schema.items).schema
+  const constant = Object.prototype.hasOwnProperty.call(schema, 'const')
   return {
-    schema: candidate,
-    reference: field['x-mint-component'] ?? candidate['x-mint-component'],
-    hasDefault,
-    defaultValue: field.default,
+    schema,
+    reference: schema['x-mint-component'],
+    hasDefault: constant || hasOwnDefault(field) || allowsNull(schema),
+    defaultValue: constant ? schema.const : hasOwnDefault(field) ? field.default : null,
   }
 }
 
@@ -117,7 +152,7 @@ function fieldType(schema: GeneratedJsonSchema, reference?: GeneratedReference):
   const type = Array.isArray(schema.type) ? schema.type.find(value => value !== 'null') : schema.type
   if (type === 'boolean') return 'toggle'
   if (type === 'number' || type === 'integer') return 'number'
-  if (type === 'array') return 'tags'
+  if (type === 'array') return schema.items?.enum ? 'multiselect' : 'tags'
   return 'text'
 }
 
@@ -125,6 +160,11 @@ function hasOwnDefault(schema: GeneratedJsonSchema): boolean {
   return Object.prototype.hasOwnProperty.call(schema, 'default')
 }
 
+function allowsNull(schema: GeneratedJsonSchema): boolean {
+  return schema.type === 'null' || (Array.isArray(schema.type) && schema.type.includes('null'))
+    || !!schema.anyOf?.some(item => item.type === 'null')
+}
+
 function humanize(value: string): string {
   return value.replace(/[_-]+/g, ' ').replace(/^\w/, character => character.toUpperCase())
 }

package/src/index.ts

@@ -1,6 +1,9 @@
 // Styles (import to ensure bundling)
 import './styles/index.css'
 
+// Typed API errors
+export * from './apiErrors'
+
 // Vue Plugin for global component registration
 export { MINTSdk, default } from './install'