@sendinel/mcp-server 1.0.9 → 1.0.11

package/build/tools/org.js

@@ -1,38 +1,14 @@
 import { randomBytes } from 'crypto';
 import { z } from 'zod';
 import { logAudit } from '../audit.js';
-import { db } from '../db.js';
+import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
+import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval } from '../lib/action-approvals.js';
+import { callSendinelV1 } from '../lib/v1-client.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const PROVIDER_SWITCH_V1_PROVIDERS = ['resend', 'ses', 'elastic-email'];
 async function callProviderSwitchApi(path, init) {
-    const apiKey = process.env.SENDINEL_API_KEY;
-    if (!apiKey)
-        return { ok: false, error: 'SENDINEL_API_KEY is required to drive provider-switch tools from MCP' };
-    const base = (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
-    const res = await fetch(`${base}${path}`, {
-        ...init,
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            'X-Sendinel-Project-Id': getProjectId(),
-            ...(init?.headers ?? {}),
-        },
-    });
-    const body = await res.text();
-    if (!res.ok) {
-        try {
-            return { ok: false, error: JSON.parse(body) };
-        }
-        catch {
-            return { ok: false, error: body || `HTTP ${res.status}` };
-        }
-    }
-    try {
-        return { ok: true, data: JSON.parse(body) };
-    }
-    catch {
-        return { ok: true, data: body };
-    }
+    return callSendinelV1(path, init);
 }
 const PLAN_LIMITS = {
     free: { contacts: 250, monthly_sends: 500, sites: 1, ai_drafts: 5, log_retention_days: 30, white_label: false },
@@ -41,16 +17,57 @@ const PLAN_LIMITS = {
     'agency-plus': { contacts: -1, monthly_sends: 500000, sites: -1, ai_drafts: -1, log_retention_days: -1, white_label: true },
     enterprise: { contacts: -1, monthly_sends: 250000, sites: 50, ai_drafts: -1, log_retention_days: -1, white_label: true },
 };
+const DANGEROUS_AUDIT_ACTIONS = new Set([
+    'contact.deleted',
+    'contact.deleted_gdpr',
+    'campaign.deleted',
+    'draft.rejected',
+    'segment.deleted',
+    'api_key.revoked',
+]);
+const isDangerousAuditAction = (action) => DANGEROUS_AUDIT_ACTIONS.has(action || '') || /deleted|revoked|gdpr/i.test(action || '');
+function addDaysUtc(date, days) {
+    const value = new Date(`${date}T00:00:00.000Z`);
+    value.setUTCDate(value.getUTCDate() + days);
+    return value.toISOString().slice(0, 10);
+}
+function dateSpanDays(from, to) {
+    const start = new Date(`${from}T00:00:00.000Z`).getTime();
+    const end = new Date(`${to}T00:00:00.000Z`).getTime();
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return 1;
+    return Math.max(1, Math.round((end - start) / 86400000) + 1);
+}
 const whiteLabelSettingsSchema = z.object({
     logo_url: z.string().url().nullable().optional(),
     favicon_url: z.string().url().nullable().optional(),
     brand_colors: z.record(z.string(), z.unknown()).optional(),
+    font_choice: z.enum(['space_grotesk', 'system', 'serif']).nullable().optional(),
     product_name: z.string().trim().min(1).max(80).nullable().optional(),
     remove_sendinel_branding: z.boolean().optional(),
     custom_from_identity: z.string().trim().min(1).max(255).nullable().optional(),
     sign_in_branding: z.record(z.string(), z.unknown()).optional(),
     support_url: z.string().url().nullable().optional(),
 });
+const memberProjectAssignmentSchema = z.object({
+    project_id: z.string().uuid(),
+    role: z.enum(['owner', 'admin', 'member']).default('member'),
+});
+async function resolveCurrentOrgId(requestedOrgId) {
+    const { data: project, error } = await db()
+        .from('projects')
+        .select('org_id')
+        .eq('id', getProjectId())
+        .maybeSingle();
+    if (error)
+        return { ok: false, error: error.message };
+    if (!project?.org_id)
+        return { ok: false, error: 'Project has no organization', code: 'NO_ORG' };
+    if (requestedOrgId && requestedOrgId !== project.org_id) {
+        return { ok: false, error: 'Organization does not belong to the current project', code: 'ORG_MISMATCH' };
+    }
+    return { ok: true, orgId: project.org_id };
+}
 function normalizeHost(host) {
     if (!host)
         return null;
@@ -86,6 +103,7 @@ function formatWhiteLabelSettings(row) {
         logo_url: row.logo_url ?? null,
         favicon_url: row.favicon_url ?? null,
         brand_colors: row.brand_colors && typeof row.brand_colors === 'object' ? row.brand_colors : {},
+        font_choice: row.font_choice ?? null,
         product_name: row.product_name ?? null,
         remove_sendinel_branding: row.remove_sendinel_branding === true,
         custom_from_identity: row.custom_from_identity ?? null,
@@ -157,6 +175,343 @@ export function registerOrgTools(server) {
             return j({ error: error.message });
         return j({ invitation_id: data.id, expires_at: data.expires_at });
     });
+    server.registerTool('remove_team_member', {
+        title: 'Remove Team Member',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Remove a member from the project organization. Cannot remove the last owner. Uses two-call confirmation plus approval before executing.',
+        inputSchema: {
+            user_id: z.string().uuid().describe('Auth user id of the member to remove, as returned by list_team_members.'),
+            org_id: z.string().uuid().optional(),
+            confirmed: z.boolean().optional().default(false).describe('Two-call confirmation. First call previews, second call with confirmed=true executes.'),
+            approval_id: z.string().uuid().optional().describe('Approval token from a previous confirmed call without approval_id. Required when the action is not autonomous.'),
+        },
+    }, async ({ user_id, org_id, confirmed, approval_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data: member, error: memberErr } = await db()
+            .from('org_members')
+            .select('id, user_id, role')
+            .eq('org_id', context.orgId)
+            .eq('user_id', user_id)
+            .maybeSingle();
+        if (memberErr)
+            return j({ error: memberErr.message });
+        if (!member)
+            return j({ error: 'Member not found', code: 'NOT_FOUND' });
+        const approvalParams = { user_id, org_id: context.orgId };
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'remove_team_member',
+                member: { user_id: member.user_id, role: member.role },
+                message: `Removing this member (role: ${member.role}) revokes their access to org ${context.orgId}. Call again with confirmed=true to proceed.`,
+            });
+        }
+        if (member.role === 'owner') {
+            const { count } = await db()
+                .from('org_members')
+                .select('id', { count: 'exact', head: true })
+                .eq('org_id', context.orgId)
+                .eq('role', 'owner');
+            if ((count ?? 0) <= 1)
+                return j({ error: 'Cannot remove the last owner', code: 'LAST_OWNER' });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('remove_team_member', approvalParams, channelContext);
+        if (!decision.allowed)
+            return j({ error: decision.reason ?? 'This channel cannot request this action.' });
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id)
+                return j(await requestApproval('remove_team_member', approvalParams, undefined, channelContext));
+            const check = await checkApproval(approval_id, { consume: true, action: 'remove_team_member', params: approvalParams });
+            if (!check.approved) {
+                return j({
+                    error: `Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`,
+                    code: `APPROVAL_${check.status.toUpperCase()}`,
+                });
+            }
+        }
+        const { error } = await db()
+            .from('org_members')
+            .delete()
+            .eq('org_id', context.orgId)
+            .eq('user_id', user_id);
+        if (error)
+            return j({ error: error.message });
+        void logAudit({
+            action: 'remove_member',
+            resourceType: 'org_member',
+            resourceId: member.id,
+            details: { org_id: context.orgId, removed_user: user_id, role: member.role },
+        }).catch(() => { });
+        return j({ ok: true, removed_user_id: user_id });
+    });
+    server.registerTool('set_team_member_role', {
+        title: 'Set Team Member Role',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: "Change a team member's role within the project organization. Uses two-call confirmation plus approval before executing.",
+        inputSchema: {
+            user_id: z.string().uuid(),
+            role: z.enum(['owner', 'admin', 'member']),
+            org_id: z.string().uuid().optional(),
+            confirmed: z.boolean().optional().default(false),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, async ({ user_id, role, org_id, confirmed, approval_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data: member, error: memberErr } = await db()
+            .from('org_members')
+            .select('id, user_id, role')
+            .eq('org_id', context.orgId)
+            .eq('user_id', user_id)
+            .maybeSingle();
+        if (memberErr)
+            return j({ error: memberErr.message });
+        if (!member)
+            return j({ error: 'Member not found', code: 'NOT_FOUND' });
+        const approvalParams = { user_id, role, org_id: context.orgId };
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'set_team_member_role',
+                member: { user_id: member.user_id, current_role: member.role, new_role: role },
+                message: `This changes ${user_id}'s role from "${member.role}" to "${role}". Call again with confirmed=true to proceed.`,
+            });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('set_team_member_role', approvalParams, channelContext);
+        if (!decision.allowed)
+            return j({ error: decision.reason ?? 'This channel cannot request this action.' });
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id)
+                return j(await requestApproval('set_team_member_role', approvalParams, undefined, channelContext));
+            const check = await checkApproval(approval_id, { consume: true, action: 'set_team_member_role', params: approvalParams });
+            if (!check.approved) {
+                return j({
+                    error: `Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`,
+                    code: `APPROVAL_${check.status.toUpperCase()}`,
+                });
+            }
+        }
+        const { data, error } = await db()
+            .from('org_members')
+            .update({ role })
+            .eq('org_id', context.orgId)
+            .eq('user_id', user_id)
+            .select('user_id, role')
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        void logAudit({
+            action: 'update_member_role',
+            resourceType: 'org_member',
+            resourceId: member.id,
+            details: { org_id: context.orgId, user_id, new_role: role },
+        }).catch(() => { });
+        return j({ member: data });
+    });
+    server.registerTool('set_member_project_access', {
+        title: 'Set Member Project Access',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: "Replace a team member's per-project access within the org (full replace, not a merge). Org owners have implicit access to all projects and cannot be scoped this way.",
+        inputSchema: {
+            user_id: z.string().uuid(),
+            projects: z.array(memberProjectAssignmentSchema),
+            org_id: z.string().uuid().optional(),
+        },
+    }, async ({ user_id, projects, org_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data: membership, error: membershipErr } = await db()
+            .from('org_members')
+            .select('role')
+            .eq('org_id', context.orgId)
+            .eq('user_id', user_id)
+            .maybeSingle();
+        if (membershipErr)
+            return j({ error: membershipErr.message });
+        if (!membership)
+            return j({ error: 'Member not found', code: 'NOT_FOUND' });
+        if (membership.role === 'owner') {
+            return j({ error: 'Org owners have implicit access to all projects', code: 'IMPLICIT_ACCESS' });
+        }
+        const { data: orgProjects, error: orgProjectsErr } = await db()
+            .from('projects')
+            .select('id')
+            .eq('org_id', context.orgId);
+        if (orgProjectsErr)
+            return j({ error: orgProjectsErr.message });
+        const validIds = new Set((orgProjects ?? []).map((project) => project.id));
+        const assignmentMap = new Map();
+        for (const project of projects)
+            assignmentMap.set(project.project_id, project.role);
+        const requestedProjects = Array.from(assignmentMap, ([project_id, role]) => ({ project_id, role }));
+        const requestedIds = requestedProjects.map((project) => project.project_id);
+        const invalidIds = requestedIds.filter((id) => !validIds.has(id));
+        if (invalidIds.length > 0)
+            return j({ error: `Invalid project IDs: ${invalidIds.join(', ')}`, code: 'INVALID_PROJECT' });
+        const idsToRemove = Array.from(validIds).filter((id) => !assignmentMap.has(id));
+        if (idsToRemove.length > 0) {
+            const { error: deleteErr } = await db()
+                .from('user_project_access')
+                .delete()
+                .eq('user_id', user_id)
+                .in('project_id', idsToRemove);
+            if (deleteErr)
+                return j({ error: deleteErr.message });
+        }
+        if (requestedProjects.length > 0) {
+            const rows = requestedProjects.map((project) => ({ user_id, project_id: project.project_id, role: project.role }));
+            const { error: upsertErr } = await db()
+                .from('user_project_access')
+                .upsert(rows, { onConflict: 'user_id,project_id' });
+            if (upsertErr)
+                return j({ error: upsertErr.message });
+        }
+        void logAudit({
+            action: 'set_member_project_access',
+            resourceType: 'org_member',
+            resourceId: user_id,
+            details: { org_id: context.orgId, project_ids: requestedIds },
+        }).catch(() => { });
+        return j({ ok: true, user_id, project_ids: requestedIds });
+    });
+    server.registerTool('list_invitations', {
+        title: 'List Invitations',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List pending (unaccepted, unexpired) invitations for the project organization.',
+        inputSchema: { org_id: z.string().uuid().optional() },
+    }, async ({ org_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data, error } = await db()
+            .from('org_invitations')
+            .select('id, email, role, invited_by, created_at, expires_at, project_ids, project_roles')
+            .eq('org_id', context.orgId)
+            .is('accepted_at', null)
+            .gt('expires_at', new Date().toISOString());
+        if (error)
+            return j({ error: error.message });
+        return j({ invitations: data ?? [] });
+    });
+    server.registerTool('resend_invitation', {
+        title: 'Resend Invitation',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: "Extend a pending invitation's expiry and return its invite URL. Does not send an email from the MCP server -- relay invite_url to the invitee directly.",
+        inputSchema: {
+            invitation_id: z.string().uuid(),
+            org_id: z.string().uuid().optional(),
+        },
+    }, async ({ invitation_id, org_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data: invitation, error: invitationErr } = await db()
+            .from('org_invitations')
+            .select('id, email, role, token, expires_at')
+            .eq('id', invitation_id)
+            .eq('org_id', context.orgId)
+            .is('accepted_at', null)
+            .gt('expires_at', new Date().toISOString())
+            .maybeSingle();
+        if (invitationErr)
+            return j({ error: invitationErr.message });
+        if (!invitation)
+            return j({ error: 'Invitation not found', code: 'NOT_FOUND' });
+        const expiresAt = new Date(Date.now() + 7 * 86400000).toISOString();
+        const { data: updated, error: updateErr } = await db()
+            .from('org_invitations')
+            .update({ expires_at: expiresAt })
+            .eq('id', invitation_id)
+            .eq('org_id', context.orgId)
+            .is('accepted_at', null)
+            .select('id')
+            .maybeSingle();
+        if (updateErr)
+            return j({ error: updateErr.message });
+        if (!updated)
+            return j({ error: 'Invitation not found', code: 'NOT_FOUND' });
+        const appUrl = (process.env.NEXT_PUBLIC_APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+        return j({
+            invitation_id: invitation.id,
+            email: invitation.email,
+            role: invitation.role,
+            expires_at: expiresAt,
+            invite_url: `${appUrl}/invite/${invitation.token}`,
+        });
+    });
+    server.registerTool('revoke_invitation', {
+        title: 'Revoke Invitation',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Revoke a pending org invitation before it is accepted.',
+        inputSchema: {
+            invitation_id: z.string().uuid(),
+            org_id: z.string().uuid().optional(),
+        },
+    }, async ({ invitation_id, org_id }) => {
+        const context = await resolveCurrentOrgId(org_id);
+        if (!context.ok)
+            return j({ error: context.error, code: context.code });
+        const { data: invitation, error: invitationErr } = await db()
+            .from('org_invitations')
+            .select('id, email, role, accepted_at')
+            .eq('id', invitation_id)
+            .eq('org_id', context.orgId)
+            .maybeSingle();
+        if (invitationErr)
+            return j({ error: invitationErr.message });
+        if (!invitation || invitation.accepted_at)
+            return j({ error: 'Invitation not found', code: 'NOT_FOUND' });
+        const { error } = await db()
+            .from('org_invitations')
+            .delete()
+            .eq('id', invitation_id)
+            .eq('org_id', context.orgId);
+        if (error)
+            return j({ error: error.message });
+        void logAudit({
+            action: 'invitation.revoked',
+            resourceType: 'org_invitation',
+            resourceId: invitation_id,
+            details: { org_id: context.orgId, email: invitation.email, role: invitation.role },
+        }).catch(() => { });
+        return j({ ok: true });
+    });
     server.registerTool('get_plan_usage', {
         title: 'Get Plan Usage',
         annotations: {
@@ -197,6 +552,168 @@ export function registerOrgTools(server) {
         description: 'Return plan limits for all plan tiers.',
         inputSchema: {},
     }, async () => j(PLAN_LIMITS));
+    server.registerTool('list_audit_log', {
+        title: 'List Audit Log',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List audit log entries for the project, filterable by action, actor, resource, and date range. Audit details match the dashboard response and may contain personal data, so this tool requires admin scope.',
+        inputSchema: {
+            action: z.string().optional(),
+            resource_type: z.string().optional(),
+            resource_id: z.string().uuid().optional(),
+            actor_id: z.string().optional(),
+            date_from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Inclusive, UTC, YYYY-MM-DD'),
+            date_to: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Inclusive, UTC, YYYY-MM-DD'),
+            limit: z.number().int().min(1).max(100).optional().default(50),
+            offset: z.number().int().min(0).optional().default(0),
+        },
+    }, async ({ action, resource_type, resource_id, actor_id, date_from, date_to, limit, offset }) => {
+        const projectId = getProjectId();
+        const effectiveLimit = limit ?? 50;
+        const effectiveOffset = offset ?? 0;
+        let query = db()
+            .from('audit_log')
+            .select('id, project_id, actor_type, actor_id, action, resource_type, resource_id, details, channel, created_at', { count: 'exact' })
+            .eq('project_id', projectId)
+            .order('created_at', { ascending: false })
+            .range(effectiveOffset, effectiveOffset + effectiveLimit - 1);
+        if (action)
+            query = query.eq('action', action);
+        if (resource_type)
+            query = query.eq('resource_type', resource_type);
+        if (resource_id)
+            query = query.eq('resource_id', resource_id);
+        if (actor_id)
+            query = query.eq('actor_id', actor_id);
+        if (date_from)
+            query = query.gte('created_at', `${date_from}T00:00:00.000Z`);
+        if (date_to)
+            query = query.lte('created_at', `${date_to}T23:59:59.999Z`);
+        const { data, count, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ entries: data ?? [], total: count ?? 0, limit: effectiveLimit, offset: effectiveOffset });
+    });
+    server.registerTool('get_audit_stats', {
+        title: 'Get Audit Stats',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Return event, unique-actor, and dangerous-event counts for an audit-log date window, plus the immediately preceding window of equal length. Requires admin scope.',
+        inputSchema: {
+            action: z.string().optional(),
+            resource_type: z.string().optional(),
+            actor_id: z.string().optional(),
+            date_from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Defaults to today, UTC'),
+            date_to: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Defaults to date_from'),
+        },
+    }, async ({ action, resource_type, actor_id, date_from, date_to }) => {
+        const projectId = getProjectId();
+        const today = new Date().toISOString().slice(0, 10);
+        const dateFrom = date_from ?? today;
+        const dateTo = date_to ?? dateFrom;
+        const fetchWindow = async (fromDate, toDate) => {
+            let query = db()
+                .from('audit_log')
+                .select('action, actor_id, actor_type, created_at', { count: 'exact' })
+                .eq('project_id', projectId)
+                .gte('created_at', `${fromDate}T00:00:00.000Z`)
+                .lte('created_at', `${toDate}T23:59:59.999Z`)
+                .order('created_at', { ascending: false })
+                .range(0, 9999);
+            if (action)
+                query = query.eq('action', action);
+            if (resource_type)
+                query = query.eq('resource_type', resource_type);
+            if (actor_id)
+                query = query.eq('actor_id', actor_id);
+            return query;
+        };
+        const spanDays = dateSpanDays(dateFrom, dateTo);
+        const previousDateTo = addDaysUtc(dateFrom, -1);
+        const previousDateFrom = addDaysUtc(dateFrom, -spanDays);
+        const [current, previous] = await Promise.all([
+            fetchWindow(dateFrom, dateTo),
+            fetchWindow(previousDateFrom, previousDateTo),
+        ]);
+        if (current.error)
+            return j({ error: current.error.message });
+        if (previous.error)
+            return j({ error: previous.error.message });
+        const rows = current.data ?? [];
+        const previousRows = previous.data ?? [];
+        const uniqueActors = new Set(rows.map((entry) => entry.actor_id || entry.actor_type).filter(Boolean)).size;
+        const previousUniqueActors = new Set(previousRows.map((entry) => entry.actor_id || entry.actor_type).filter(Boolean)).size;
+        const dangerousEvents = rows.filter((entry) => isDangerousAuditAction(entry.action)).length;
+        return j({
+            events: current.count ?? rows.length,
+            uniqueActors,
+            dangerousEvents,
+            previousEvents: previous.count ?? previousRows.length,
+            previousUniqueActors,
+            dateFrom,
+            dateTo,
+            previousDateFrom,
+            previousDateTo,
+        });
+    });
+    server.registerTool('list_audit_actions', {
+        title: 'List Audit Actions',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List distinct audit-log action values seen for this project, for building list_audit_log filters.',
+        inputSchema: {},
+    }, async () => {
+        const projectId = getProjectId();
+        const { data, error } = await db()
+            .from('audit_log')
+            .select('action')
+            .eq('project_id', projectId)
+            .order('action', { ascending: true })
+            .limit(1000);
+        if (error)
+            return j({ error: error.message });
+        const actions = Array.from(new Set((data ?? []).map((row) => row.action).filter(Boolean)));
+        return j({ actions });
+    });
+    server.registerTool('get_model_registry', {
+        title: 'Get Model Registry',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List runtime model-registry overrides, including global and org-scoped role mappings.',
+        inputSchema: { org_id: z.string().uuid().optional() },
+    }, async ({ org_id }) => {
+        const columns = 'role, org_id, model_id, note, updated_at';
+        const scopedRows = org_id
+            ? await adminDb().from('model_registry').select(columns).eq('org_id', org_id)
+            : { data: [], error: null };
+        if (scopedRows.error)
+            return j({ error: scopedRows.error.message });
+        const globalRows = await adminDb().from('model_registry').select(columns).is('org_id', null);
+        if (globalRows.error)
+            return j({ error: globalRows.error.message });
+        return j({
+            overrides: [
+                ...(scopedRows.data ?? []),
+                ...(globalRows.data ?? []),
+            ],
+        });
+    });
     server.registerTool('get_white_label_settings', {
         title: 'Get White Label Settings',
         annotations: {
@@ -319,8 +836,7 @@ export function registerOrgTools(server) {
     }, async ({ site_id, to_provider }) => {
         const result = await callProviderSwitchApi('/api/dashboard/provider-switch/start', {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ site_id, to_provider }),
+            body: { site_id, to_provider },
         });
         return result.ok ? j(result.data) : j({ error: result.error });
     });
@@ -337,8 +853,9 @@ export function registerOrgTools(server) {
             id: z.string().uuid(),
         },
     }, async ({ id }) => {
-        const result = await callProviderSwitchApi(`/api/dashboard/provider-switch/status?id=${encodeURIComponent(id)}`, {
+        const result = await callProviderSwitchApi('/api/dashboard/provider-switch/status', {
             method: 'GET',
+            query: { id },
         });
         return result.ok ? j(result.data) : j({ error: result.error });
     });
@@ -357,8 +874,7 @@ export function registerOrgTools(server) {
     }, async ({ id }) => {
         const result = await callProviderSwitchApi('/api/dashboard/provider-switch/rollback', {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ id }),
+            body: { id },
         });
         return result.ok ? j(result.data) : j({ error: result.error });
     });