@open-mercato/core 0.4.5-develop-811deeb983 → 0.4.5-develop-3d8e759e45

package/src/modules/catalog/inbox-actions.ts

@@ -0,0 +1,60 @@
+import type { InboxActionDefinition, InboxActionExecutionContext } from '@open-mercato/shared/modules/inbox-actions'
+import { createProductPayloadSchema } from '../inbox_ops/data/validators'
+import type { CreateProductPayload } from '../inbox_ops/data/validators'
+import {
+  asHelperContext,
+  ExecutionError,
+  executeCommand,
+  resolveProductDiscrepanciesInProposal,
+} from '../inbox_ops/lib/executionHelpers'
+
+async function executeCreateProductAction(
+  action: { id: string; proposalId: string; payload: unknown },
+  ctx: InboxActionExecutionContext,
+): Promise<{ createdEntityId?: string | null; createdEntityType?: string | null }> {
+  const hCtx = asHelperContext(ctx)
+  const payload = action.payload as CreateProductPayload
+
+  const createInput: Record<string, unknown> = {
+    organizationId: hCtx.organizationId,
+    tenantId: hCtx.tenantId,
+    title: payload.title,
+    productType: 'simple',
+    isActive: true,
+  }
+
+  if (payload.sku) createInput.sku = payload.sku
+  if (payload.description) createInput.description = payload.description
+  if (payload.currencyCode) createInput.primaryCurrencyCode = payload.currencyCode
+
+  const result = await executeCommand<Record<string, unknown>, { productId?: string }>(
+    hCtx,
+    'catalog.products.create',
+    createInput,
+  )
+
+  if (!result.productId) {
+    throw new ExecutionError('Product creation did not return a product ID', 500)
+  }
+
+  await resolveProductDiscrepanciesInProposal(hCtx.em, action.proposalId, payload.title, result.productId, {
+    tenantId: hCtx.tenantId,
+    organizationId: hCtx.organizationId,
+  })
+
+  return { createdEntityId: result.productId, createdEntityType: 'catalog_product' }
+}
+
+export const inboxActions: InboxActionDefinition[] = [
+  {
+    type: 'create_product',
+    requiredFeature: 'catalog.products.manage',
+    payloadSchema: createProductPayloadSchema,
+    label: 'Create Product',
+    promptSchema: `create_product payload:
+{ title: string, sku?: string, unitPrice?: string, currencyCode?: string (3-letter ISO), kind?: "product"|"service", description?: string }`,
+    execute: executeCreateProductAction,
+  },
+]
+
+export default inboxActions

package/src/modules/customers/inbox-actions.ts

@@ -0,0 +1,285 @@
+import type { InboxActionDefinition, InboxActionExecutionContext } from '@open-mercato/shared/modules/inbox-actions'
+import {
+  createContactPayloadSchema,
+  linkContactPayloadSchema,
+  logActivityPayloadSchema,
+  draftReplyPayloadSchema,
+} from '../inbox_ops/data/validators'
+import type {
+  CreateContactPayload,
+  LinkContactPayload,
+  LogActivityPayload,
+  DraftReplyPayload,
+} from '../inbox_ops/data/validators'
+import {
+  asHelperContext,
+  ExecutionError,
+  executeCommand,
+  resolveEntityClass,
+  resolveCustomerEntityIdByEmail,
+  resolveContactIdByNameAndType,
+} from '../inbox_ops/lib/executionHelpers'
+import { splitPersonName } from '../inbox_ops/lib/contactValidation'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+
+// ---------------------------------------------------------------------------
+// create_contact
+// ---------------------------------------------------------------------------
+
+async function executeCreateContactAction(
+  action: { id: string; proposalId: string; payload: unknown },
+  ctx: InboxActionExecutionContext,
+): Promise<{ createdEntityId?: string | null; createdEntityType?: string | null; matchedEntityId?: string | null; matchedEntityType?: string | null }> {
+  const hCtx = asHelperContext(ctx)
+  const payload = action.payload as CreateContactPayload
+
+  const CustomerEntityClass = resolveEntityClass(hCtx, 'CustomerEntity')
+  if (payload.email && CustomerEntityClass) {
+    const emailLower = payload.email.trim().toLowerCase()
+    let existingContact = await findOneWithDecryption(
+      hCtx.em,
+      CustomerEntityClass,
+      {
+        primaryEmail: emailLower,
+        tenantId: hCtx.tenantId,
+        organizationId: hCtx.organizationId,
+        deletedAt: null,
+      },
+      undefined,
+      { tenantId: hCtx.tenantId, organizationId: hCtx.organizationId },
+    )
+    if (!existingContact) {
+      const candidates = await findWithDecryption(
+        hCtx.em,
+        CustomerEntityClass,
+        {
+          tenantId: hCtx.tenantId,
+          organizationId: hCtx.organizationId,
+          deletedAt: null,
+        },
+        { limit: 100, orderBy: { createdAt: 'DESC' } },
+        { tenantId: hCtx.tenantId, organizationId: hCtx.organizationId },
+      )
+      existingContact = candidates.find(
+        (e) => e.primaryEmail && e.primaryEmail.toLowerCase() === emailLower,
+      ) ?? null
+    }
+    if (existingContact) {
+      const isCompany = existingContact.kind === 'company'
+      return {
+        createdEntityId: existingContact.id,
+        createdEntityType: isCompany ? 'customer_company' : 'customer_person',
+        matchedEntityId: existingContact.id,
+        matchedEntityType: isCompany ? 'company' : 'person',
+      }
+    }
+  }
+
+  if (payload.type === 'company') {
+    const result = await executeCommand<Record<string, unknown>, { entityId?: string }>(
+      hCtx,
+      'customers.companies.create',
+      {
+        organizationId: hCtx.organizationId,
+        tenantId: hCtx.tenantId,
+        displayName: payload.name,
+        legalName: payload.companyName ?? payload.name,
+        primaryEmail: payload.email,
+        primaryPhone: payload.phone,
+        source: payload.source,
+      },
+    )
+    if (!result.entityId) {
+      throw new ExecutionError('Company creation did not return an entity ID', 500)
+    }
+    return { createdEntityId: result.entityId, createdEntityType: 'customer_company' }
+  }
+
+  const { firstName, lastName } = splitPersonName(payload.name, payload.email)
+  const result = await executeCommand<Record<string, unknown>, { entityId?: string }>(
+    hCtx,
+    'customers.people.create',
+    {
+      organizationId: hCtx.organizationId,
+      tenantId: hCtx.tenantId,
+      displayName: payload.name,
+      firstName,
+      lastName,
+      primaryEmail: payload.email,
+      primaryPhone: payload.phone,
+      jobTitle: payload.role,
+      source: payload.source,
+    },
+  )
+
+  if (!result.entityId) {
+    throw new ExecutionError('Person creation did not return an entity ID', 500)
+  }
+
+  return { createdEntityId: result.entityId, createdEntityType: 'customer_person' }
+}
+
+// ---------------------------------------------------------------------------
+// link_contact
+// ---------------------------------------------------------------------------
+
+function executeLinkContactAction(
+  action: { id: string; proposalId: string; payload: unknown },
+): { createdEntityId?: string | null; createdEntityType?: string | null; matchedEntityId?: string | null; matchedEntityType?: string | null } {
+  const payload = action.payload as LinkContactPayload
+  return {
+    createdEntityId: payload.contactId,
+    createdEntityType: payload.contactType === 'company' ? 'customer_company' : 'customer_person',
+    matchedEntityId: payload.contactId,
+    matchedEntityType: payload.contactType,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// log_activity
+// ---------------------------------------------------------------------------
+
+async function executeLogActivityAction(
+  action: { id: string; proposalId: string; payload: unknown },
+  ctx: InboxActionExecutionContext,
+): Promise<{ createdEntityId?: string | null; createdEntityType?: string | null }> {
+  const hCtx = asHelperContext(ctx)
+  let payload = action.payload as LogActivityPayload
+
+  if (!payload.contactId) {
+    const resolved = await resolveContactIdByNameAndType(hCtx, payload.contactName, payload.contactType)
+    if (resolved) {
+      payload = { ...payload, contactId: resolved }
+    } else {
+      throw new ExecutionError(
+        `log_activity requires contactId — could not resolve contact "${payload.contactName}" (${payload.contactType})`,
+        400,
+      )
+    }
+  }
+
+  const result = await executeCommand<Record<string, unknown>, { activityId?: string }>(
+    hCtx,
+    'customers.activities.create',
+    {
+      organizationId: hCtx.organizationId,
+      tenantId: hCtx.tenantId,
+      entityId: payload.contactId,
+      activityType: payload.activityType,
+      subject: payload.subject,
+      body: payload.body,
+      authorUserId: hCtx.userId,
+    },
+  )
+
+  if (!result.activityId) {
+    throw new ExecutionError('Activity creation did not return an activity ID', 500)
+  }
+
+  return { createdEntityId: result.activityId, createdEntityType: 'customer_activity' }
+}
+
+// ---------------------------------------------------------------------------
+// draft_reply
+// ---------------------------------------------------------------------------
+
+async function executeDraftReplyAction(
+  action: { id: string; proposalId: string; payload: unknown },
+  ctx: InboxActionExecutionContext,
+): Promise<{ createdEntityId?: string | null; createdEntityType?: string | null }> {
+  const hCtx = asHelperContext(ctx)
+  const payload = action.payload as DraftReplyPayload
+  const payloadRecord = action.payload as Record<string, unknown>
+  const explicitContactId = typeof payloadRecord.contactId === 'string' ? payloadRecord.contactId : null
+  const contactId = explicitContactId ?? (await resolveCustomerEntityIdByEmail(hCtx, payload.to))
+
+  if (!contactId) {
+    throw new ExecutionError(
+      `No matching contact found for "${payload.to}". Create the contact first or link an existing one.`,
+      400,
+    )
+  }
+
+  const details = [
+    payload.body.trim(),
+    '',
+    '---',
+    `Draft reply target: ${payload.to}`,
+    `Subject: ${payload.subject}`,
+    payload.context ? `Context: ${payload.context}` : null,
+    `InboxOps Proposal: ${action.proposalId}`,
+    `InboxOps Action: ${action.id}`,
+  ]
+    .filter((line) => typeof line === 'string' && line.length > 0)
+    .join('\n')
+
+  const result = await executeCommand<Record<string, unknown>, { activityId?: string }>(
+    hCtx,
+    'customers.activities.create',
+    {
+      organizationId: hCtx.organizationId,
+      tenantId: hCtx.tenantId,
+      entityId: contactId,
+      activityType: 'email',
+      subject: payload.subject,
+      body: details,
+      authorUserId: hCtx.userId,
+    },
+  )
+
+  if (!result.activityId) {
+    throw new ExecutionError('Draft reply activity did not return an activity ID', 500)
+  }
+
+  return { createdEntityId: result.activityId, createdEntityType: 'customer_activity' }
+}
+
+// ---------------------------------------------------------------------------
+// Exported action definitions
+// ---------------------------------------------------------------------------
+
+export const inboxActions: InboxActionDefinition[] = [
+  {
+    type: 'create_contact',
+    requiredFeature: 'customers.people.manage',
+    payloadSchema: createContactPayloadSchema,
+    label: 'Create Contact',
+    promptSchema: `create_contact payload:
+{ type: "person"|"company", name: string, email?: string, phone?: string, companyName?: string, role?: string, source: "inbox_ops" }`,
+    promptRules: [
+      'For create_contact: always include email when available from the thread. Set source to "inbox_ops", type must be lowercase "person" or "company".',
+      'For create_contact with type "person": if the sender\'s display name is not available in the email header or signature, attempt to derive a human-readable name from the email address (e.g., john.doe@company.com -> "John Doe", m.smith@corp.net -> "M Smith"). If the email address does not contain a derivable name (e.g., info@, noreply@), use the full email address as the name. Always aim to provide both a first and last name when possible.',
+    ],
+    execute: executeCreateContactAction,
+  },
+  {
+    type: 'link_contact',
+    requiredFeature: 'customers.people.manage',
+    payloadSchema: linkContactPayloadSchema,
+    label: 'Link Contact',
+    promptSchema: `link_contact payload:
+{ emailAddress: string (email), contactId: uuid, contactType: "person"|"company", contactName: string }`,
+    execute: (action) => Promise.resolve(executeLinkContactAction(action)),
+  },
+  {
+    type: 'log_activity',
+    requiredFeature: 'customers.activities.manage',
+    payloadSchema: logActivityPayloadSchema,
+    label: 'Log Activity',
+    promptSchema: `log_activity payload:
+{ contactId?: uuid, contactType: "person"|"company", contactName: string, activityType: "email"|"call"|"meeting"|"note", subject: string, body: string }`,
+    execute: executeLogActivityAction,
+  },
+  {
+    type: 'draft_reply',
+    requiredFeature: 'inbox_ops.replies.send',
+    payloadSchema: draftReplyPayloadSchema,
+    label: 'Draft Reply',
+    promptSchema: `draft_reply payload:
+{ to: string (email), toName?: string, subject: string, body: string, context?: string }`,
+    promptRules: ['For draft_reply: include ERP context when available.'],
+    execute: executeDraftReplyAction,
+  },
+]
+
+export default inboxActions

package/src/modules/inbox_ops/api/emails/[id]/route.ts

@@ -10,6 +10,7 @@ import {
 
 export const metadata = {
   GET: { requireAuth: true, requireFeatures: ['inbox_ops.log.view'] },
+  DELETE: { requireAuth: true, requireFeatures: ['inbox_ops.proposals.manage'] },
 }
 
 export async function GET(req: Request) {
@@ -50,6 +51,42 @@ export async function GET(req: Request) {
   }
 }
 
+export async function DELETE(req: Request) {
+  try {
+    const url = new URL(req.url)
+    const id = extractPathSegment(url, 'emails')
+
+    if (!id) {
+      return NextResponse.json({ error: 'Missing email ID' }, { status: 400 })
+    }
+
+    const ctx = await resolveRequestContext(req)
+
+    const updated = await ctx.em.nativeUpdate(
+      InboxEmail,
+      {
+        id,
+        organizationId: ctx.organizationId,
+        tenantId: ctx.tenantId,
+        deletedAt: null,
+      },
+      { deletedAt: new Date() },
+    )
+
+    if (updated === 0) {
+      return NextResponse.json({ error: 'Email not found' }, { status: 404 })
+    }
+
+    return NextResponse.json({ ok: true })
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+    console.error('[inbox_ops:emails:delete] Error:', err)
+    return NextResponse.json({ error: 'Failed to delete email' }, { status: 500 })
+  }
+}
+
 export const openApi: OpenApiRouteDoc = {
   tag: 'InboxOps',
   summary: 'Email detail',
@@ -61,5 +98,12 @@ export const openApi: OpenApiRouteDoc = {
         { status: 404, description: 'Email not found' },
       ],
     },
+    DELETE: {
+      summary: 'Soft-delete an inbox email',
+      responses: [
+        { status: 200, description: 'Email deleted' },
+        { status: 404, description: 'Email not found' },
+      ],
+    },
   },
 }

package/src/modules/inbox_ops/api/extract/route.ts

@@ -0,0 +1,94 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { InboxEmail } from '../../data/entities'
+import { emitInboxOpsEvent } from '../../events'
+import { resolveRequestContext, handleRouteError } from '../routeHelpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['inbox_ops.proposals.manage'] },
+}
+
+const extractRequestSchema = z.object({
+  text: z.string().min(1, 'Text is required').max(100_000, 'Text exceeds maximum length'),
+  title: z.string().max(500).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+})
+
+export async function POST(req: Request) {
+  try {
+    const ctx = await resolveRequestContext(req)
+
+    let body: unknown
+    try {
+      body = await req.json()
+    } catch {
+      return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 })
+    }
+
+    const parsed = extractRequestSchema.safeParse(body)
+    if (!parsed.success) {
+      const errors = parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')
+      return NextResponse.json({ error: errors }, { status: 400 })
+    }
+
+    const { text, title, metadata: inputMetadata } = parsed.data
+
+    const maxTextSize = parseInt(process.env.INBOX_OPS_MAX_TEXT_SIZE || '204800', 10)
+    const truncatedText = text.slice(0, maxTextSize)
+
+    const email = ctx.em.create(InboxEmail, {
+      forwardedByAddress: ctx.userId,
+      forwardedByName: null,
+      toAddress: 'text-extract',
+      subject: title || 'Text extraction',
+      cleanedText: truncatedText,
+      rawText: truncatedText,
+      receivedAt: new Date(),
+      status: 'received' as const,
+      isActive: true,
+      organizationId: ctx.organizationId,
+      tenantId: ctx.tenantId,
+      metadata: {
+        ...inputMetadata,
+        source: 'text_extract',
+        submittedByUserId: ctx.userId,
+      },
+    })
+
+    ctx.em.persist(email)
+    await ctx.em.flush()
+
+    try {
+      await emitInboxOpsEvent('inbox_ops.email.received', {
+        emailId: email.id,
+        tenantId: ctx.tenantId,
+        organizationId: ctx.organizationId,
+        forwardedByAddress: ctx.userId,
+        subject: title || 'Text extraction',
+      })
+    } catch (eventError) {
+      console.error('[inbox_ops:extract] Failed to emit email.received event:', eventError)
+    }
+
+    return NextResponse.json({ ok: true, emailId: email.id })
+  } catch (err) {
+    return handleRouteError(err, 'extract text')
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'InboxOps',
+  summary: 'Extract actions from raw text',
+  methods: {
+    POST: {
+      summary: 'Submit raw text for LLM extraction',
+      description: 'Creates an InboxEmail record from raw text and triggers the extraction pipeline. The extraction runs asynchronously.',
+      responses: [
+        { status: 200, description: 'Extraction queued successfully' },
+        { status: 400, description: 'Invalid request body' },
+        { status: 401, description: 'Unauthorized' },
+      ],
+    },
+  },
+}

package/src/modules/inbox_ops/api/proposals/[id]/translate/route.ts

@@ -22,7 +22,12 @@ export async function POST(req: Request) {
     const proposal = await resolveProposal(new URL(req.url), ctx)
     if (isErrorResponse(proposal)) return proposal
 
-    const body = await req.json()
+    let body: unknown
+    try {
+      body = await req.json()
+    } catch {
+      return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 })
+    }
     const parsed = translateProposalSchema.safeParse(body)
     if (!parsed.success) {
       return NextResponse.json({ error: 'Invalid request', details: parsed.error.issues }, { status: 400 })

package/src/modules/inbox_ops/api/proposals/counts/route.ts

@@ -18,6 +18,8 @@ export async function GET(req: Request) {
       isActive: true,
     }
 
+    // em.count() is safe here — filter fields (status, organizationId, tenantId,
+    // deletedAt, isActive) are not encrypted, so decryption helpers are not needed.
     const [pending, partial, accepted, rejected] = await Promise.all([
       ctx.em.count(InboxProposal, { ...scope, status: 'pending' }),
       ctx.em.count(InboxProposal, { ...scope, status: 'partial' }),

package/src/modules/inbox_ops/backend/inbox-ops/log/page.meta.ts

@@ -3,12 +3,12 @@ export const metadata = {
   requireFeatures: ['inbox_ops.log.view'],
   pageTitle: 'Processing Log',
   pageTitleKey: 'inbox_ops.nav.log',
-  pageGroup: 'InboxOps',
+  pageGroup: 'AI Inbox Actions',
   pageGroupKey: 'inbox_ops.nav.group',
   pageOrder: 910,
   navHidden: true,
   breadcrumb: [
-    { label: 'InboxOps', labelKey: 'inbox_ops.nav.group', href: '/backend/inbox-ops' },
+    { label: 'AI Inbox Actions', labelKey: 'inbox_ops.nav.group', href: '/backend/inbox-ops' },
     { label: 'Processing Log', labelKey: 'inbox_ops.nav.log' },
   ],
 }

package/src/modules/inbox_ops/backend/inbox-ops/log/page.tsx

@@ -8,6 +8,8 @@ import type { ColumnDef } from '@tanstack/react-table'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { ErrorMessage } from '@open-mercato/ui/backend/detail'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { ArrowLeft, RefreshCw } from 'lucide-react'
 
@@ -44,41 +46,55 @@ export default function ProcessingLogPage() {
   const [pageSize] = React.useState(25)
   const [statusFilter, setStatusFilter] = React.useState<string | undefined>()
   const [isLoading, setIsLoading] = React.useState(true)
+  const [error, setError] = React.useState<string | null>(null)
   const [retryingEmailId, setRetryingEmailId] = React.useState<string | null>(null)
+  const { runMutation } = useGuardedMutation<Record<string, unknown>>({
+    contextId: 'inbox-ops-log',
+  })
 
   const loadEmails = React.useCallback(async () => {
     setIsLoading(true)
+    setError(null)
     const params = new URLSearchParams()
     params.set('page', String(page))
     params.set('pageSize', String(pageSize))
     if (statusFilter) params.set('status', statusFilter)
 
-    const result = await apiCall<EmailListResponse>(`/api/inbox_ops/emails?${params}`)
-    if (result?.ok && result.result?.items) {
-      setItems(result.result.items)
-      setTotal(result.result.total || 0)
+    try {
+      const result = await apiCall<EmailListResponse>(`/api/inbox_ops/emails?${params}`)
+      if (result?.ok && result.result?.items) {
+        setItems(result.result.items)
+        setTotal(result.result.total || 0)
+      } else {
+        setError(t('inbox_ops.log.load_failed', 'Failed to load processing log'))
+      }
+    } catch {
+      setError(t('inbox_ops.log.load_failed', 'Failed to load processing log'))
     }
     setIsLoading(false)
-  }, [page, pageSize, statusFilter])
+  }, [page, pageSize, statusFilter, t])
 
   React.useEffect(() => { loadEmails() }, [loadEmails])
 
   const handleRetryEmail = React.useCallback(async (emailId: string) => {
     setRetryingEmailId(emailId)
-    const result = await apiCall<{ ok: boolean; error?: string }>(
-      `/api/inbox_ops/emails/${emailId}/reprocess`,
-      { method: 'POST' },
-    )
+    const result = await runMutation({
+      operation: () => apiCall<{ ok: boolean; error?: string }>(
+        `/api/inbox_ops/emails/${emailId}/reprocess`,
+        { method: 'POST' },
+      ),
+      context: {},
+    })
 
     if (result?.ok && result.result?.ok) {
-      flash(`${t('inbox_ops.action.retry', 'Retry')} ${t('inbox_ops.status.processing', 'Processing')}`, 'success')
+      flash(t('inbox_ops.flash.reprocessing_started', 'Reprocessing started'), 'success')
       await loadEmails()
     } else {
       flash(result?.result?.error || t('inbox_ops.extraction_failed', 'Extraction failed'), 'error')
     }
 
     setRetryingEmailId(null)
-  }, [loadEmails, t])
+  }, [loadEmails, t, runMutation])
 
   const columns: ColumnDef<EmailRow>[] = React.useMemo(() => [
     {
@@ -101,8 +117,16 @@ export default function ProcessingLogPage() {
       accessorKey: 'status',
       header: t('inbox_ops.log.status', 'Status'),
       cell: ({ row }) => {
+        const statusLabels: Record<string, string> = {
+          received: t('inbox_ops.log.tab_received', 'Received'),
+          processing: t('inbox_ops.log.tab_processing', 'Processing'),
+          processed: t('inbox_ops.log.tab_processed', 'Processed'),
+          needs_review: t('inbox_ops.log.tab_needs_review', 'Needs Review'),
+          failed: t('inbox_ops.log.tab_failed', 'Failed'),
+        }
         const color = STATUS_COLORS[row.original.status] || 'bg-gray-100 text-gray-800'
-        return <span className={`inline-flex items-center px-2 py-0.5 rounded text-xs font-medium capitalize ${color}`}>{row.original.status}</span>
+        const label = statusLabels[row.original.status] || row.original.status
+        return <span className={`inline-flex items-center px-2 py-0.5 rounded text-xs font-medium ${color}`}>{label}</span>
       },
     },
     {
@@ -134,6 +158,7 @@ export default function ProcessingLogPage() {
         const isRetrying = retryingEmailId === row.original.id
         return (
           <Button
+            type="button"
             variant="outline"
             size="sm"
             className="h-8"
@@ -161,7 +186,7 @@ export default function ProcessingLogPage() {
     <Page>
       <div className="flex items-center gap-3 px-3 py-3 md:px-6 md:py-4">
         <Link href="/backend/inbox-ops">
-          <Button variant="ghost" size="sm"><ArrowLeft className="h-4 w-4" /></Button>
+          <Button type="button" variant="ghost" size="sm"><ArrowLeft className="h-4 w-4" /></Button>
         </Link>
         <h1 className="text-lg font-semibold">{t('inbox_ops.processing_log', 'Processing Log')}</h1>
       </div>
@@ -170,6 +195,7 @@ export default function ProcessingLogPage() {
         <div className="flex items-center gap-2 px-3 py-2 md:px-0 overflow-x-auto">
           {tabs.map((tab) => (
             <Button
+              type="button"
               key={tab.value ?? 'all'}
               variant={statusFilter === tab.value ? 'default' : 'outline'}
               size="sm"
@@ -180,6 +206,9 @@ export default function ProcessingLogPage() {
           ))}
         </div>
 
+        {error ? (
+          <ErrorMessage label={error} />
+        ) : (
         <div className="overflow-auto">
           <div className="min-w-[640px]">
             <DataTable
@@ -196,6 +225,7 @@ export default function ProcessingLogPage() {
             />
           </div>
         </div>
+        )}
       </PageBody>
     </Page>
   )