@inkeep/agents-manage-ui 0.1.0

package/src/app/api/signoz/route.ts

@@ -0,0 +1,115 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import axios from 'axios';
+import axiosRetry from 'axios-retry';
+import { getLogger } from '@/lib/logger';
+
+
+// Configure axios retry
+axiosRetry(axios, { 
+  retries: 3,
+  retryDelay: axiosRetry.exponentialDelay 
+});
+
+const SIGNOZ_URL = process.env.SIGNOZ_URL || 'http://localhost:3080';
+const SIGNOZ_API_KEY = process.env.SIGNOZ_API_KEY || '';
+
+// Validation schema for the request body
+const signozRequestSchema = z.object({
+  start: z.number().int().positive(),
+  end: z.number().int().positive(),
+  step: z.number().int().positive().optional().default(60),
+  variables: z.record(z.string(), z.any()).optional().default({}),
+  compositeQuery: z.object({
+    queryType: z.string(),
+    panelType: z.string(),
+    builderQueries: z.record(z.string(), z.any()),
+  }),
+  dataSource: z.string().optional(),
+});
+
+// Custom validation function for time ranges
+function validateTimeRange(start: number, end: number): { valid: boolean; error?: string } {
+  const now = Date.now();
+
+  if (start >= now) {
+    return { valid: false, error: 'Start time cannot be in the future' };
+  }
+
+  if (end >= now) {
+    return { valid: false, error: 'End time cannot be in the future' };
+  }
+
+  if (start >= end) {
+    return { valid: false, error: 'Start time must be before end time' };
+  }
+
+  return { valid: true };
+}
+
+export async function POST(request: NextRequest) {
+  const logger = getLogger('signoz-proxy');
+  try {
+    const body = await request.json();
+
+    // Validate request body structure
+    const validationResult = signozRequestSchema.safeParse(body);
+    if (!validationResult.success) {
+      return NextResponse.json(
+        {
+          error: 'Invalid request body',
+          details: validationResult.error.flatten(),
+        },
+        { status: 400 }
+      );
+    }
+
+    const validatedBody = validationResult.data;
+
+    // Validate time range
+    const timeValidation = validateTimeRange(validatedBody.start, validatedBody.end);
+    if (!timeValidation.valid) {
+      return NextResponse.json(
+        {
+          error: 'Invalid time range',
+          details: timeValidation.error,
+        },
+        { status: 400 }
+      );
+    }
+
+    const signozEndpoint = `${SIGNOZ_URL}/api/v4/query_range`;
+    logger.info({ endpoint: signozEndpoint }, 'Calling SigNoz');
+
+    const response = await axios.post(signozEndpoint, validatedBody, {
+      headers: {
+        'Content-Type': 'application/json',
+        'SIGNOZ-API-KEY': SIGNOZ_API_KEY,
+      },
+      timeout: 30000,
+    });
+
+    logger.info({ status: response.status }, 'SigNoz response received');
+
+    const data = response.data;
+    logger.info({ dataLength: JSON.stringify(data).length }, 'SigNoz response data received');
+
+    return NextResponse.json(data);
+  } catch (error) {
+    logger.error({ error, stack: error instanceof Error ? error.stack : undefined }, 'Error proxying to SigNoz');
+    return NextResponse.json(
+      {
+        error: 'Failed to connect to SigNoz',
+        details: error instanceof Error ? error.message : 'Unknown error',
+      },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    status: 'ok',
+    configured: !!SIGNOZ_URL && !!SIGNOZ_API_KEY,
+  });
+}

package/src/app/globals.css

@@ -0,0 +1,261 @@
+@import "@xyflow/react/dist/style.css";
+@import "tailwindcss";
+@import "tw-animate-css";
+@plugin 'tailwind-scrollbar';
+@source "../../node_modules/streamdown/dist/index.js";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme {
+  --text-2xs: 0.688rem; /* 11px */
+  --color-gray-50: oklch(0.985 0.001 106.423);
+  --color-gray-100: oklch(0.97 0.001 106.424);
+  --color-gray-200: oklch(0.923 0.003 48.717);
+  --color-gray-300: oklch(0.869 0.005 56.366);
+  --color-gray-400: oklch(0.709 0.01 56.259);
+  --color-gray-500: oklch(0.553 0.013 58.071);
+  --color-gray-600: oklch(0.444 0.011 73.639);
+  --color-gray-700: oklch(0.374 0.01 67.558);
+  --color-gray-800: oklch(0.268 0.007 34.298);
+  --color-gray-900: oklch(0.216 0.006 56.043);
+  --color-gray-950: oklch(0.147 0.004 49.25);
+
+  /* brand colors */
+  --color-azure-blue: #3784ff;
+  --color-sky-blue: #69a3ff;
+  --color-crystal-blue: #d5e5ff;
+  --color-morning-mist: #fbf9f4;
+  --color-night-sky: #231f20;
+  --color-blue-dark: #29325c;
+  --color-cream: #f7f4ed;
+  --color-white-cream: #fff5e1;
+  --color-orange-light: #fbe1bc;
+  --color-gray-light: #5f5c62;
+
+  /* based on azure blue (#3784ff) */
+  --color-azure-50: oklch(0.9697 0.0148 251.16);
+  --color-azure-100: oklch(0.9308 0.0339 253.71);
+  --color-azure-200: oklch(0.8807 0.0599 252.33);
+  --color-azure-300: oklch(0.8092 0.0999 249.58);
+  --color-azure-400: oklch(0.7135 0.1524 254.03);
+  --color-azure-500: oklch(0.6321 0.1983 259.59);
+  --color-azure-600: oklch(0.5468 0.2329 262.71);
+  --color-azure-700: oklch(0.4895 0.233 263.93);
+  --color-azure-800: oklch(0.4234 0.195 264.97);
+  --color-azure-900: oklch(0.3773 0.1488 264.94);
+  --color-azure-950: oklch(0.2785 0.0961 267.56);
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-inter);
+  --font-mono: var(--font-jetbrains-mono);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+
+  --animate-bounce-dot: bounce-dot 1.5s infinite ease-in-out;
+
+  @keyframes bounce-dot {
+    0%,
+    100% {
+      opacity: 0.3;
+      transform: translateY(0);
+    }
+    100% {
+      opacity: 1;
+      transform: translateY(-5px);
+    }
+  }
+}
+
+@keyframes shine {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+
+.animate-shine {
+  animation: shine 2s linear infinite;
+  animation-delay: 0s;
+}
+
+:root {
+  --radius: 0.625rem;
+  --background: oklch(1 0 0);
+  --foreground: var(--color-stone-900);
+  --card: oklch(1 0 0);
+  --card-foreground: var(--color-stone-900);
+  --popover: oklch(1 0 0);
+  --popover-foreground: var(--color-stone-900);
+  --primary: oklch(0.6321 0.1983 259.59);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: var(--color-stone-100);
+  --secondary-foreground: var(--color-stone-800);
+  --muted: var(--color-stone-100);
+  --muted-foreground: var(--color-stone-600);
+  --accent: var(--color-stone-100);
+  --accent-foreground: var(--color-stone-800);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: var(--color-stone-200);
+  --input: var(--color-stone-200);
+  --ring: var(--color-stone-400);
+  --chart-1: var(--color-azure-blue);
+  --chart-2: oklch(0.6 0.118 184.704);
+  --chart-3: oklch(0.398 0.07 227.392);
+  --chart-4: oklch(0.828 0.189 84.429);
+  --chart-5: oklch(0.769 0.188 70.08);
+  --sidebar: var(--color-stone-50);
+  --sidebar-foreground: var(--color-stone-900);
+  --sidebar-primary: var(--color-stone-800);
+  --sidebar-primary-foreground: var(--color-stone-50);
+  --sidebar-accent: oklch(0.3773 0.1488 264.94 / 3.92%); /* based off of azure-900 with lower opacity */
+  --sidebar-accent-foreground: var(--color-azure-600);
+  --sidebar-border: var(--color-stone-200);
+  --sidebar-ring: var(--color-stone-400);
+}
+
+.dark {
+  --background: oklch(0.141 0.005 285.823);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.21 0.006 285.885);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.21 0.006 285.885);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: var(--color-sky-blue);
+  --primary-foreground: oklch(0.21 0.006 285.885);
+  --secondary: oklch(0.274 0.006 286.033);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.274 0.006 286.033);
+  --muted-foreground: oklch(0.705 0.015 286.067);
+  --accent: oklch(0.274 0.006 286.033);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.552 0.016 285.938);
+  --chart-1: var(--color-sky-blue);
+  --chart-2: oklch(0.696 0.17 162.48);
+  --chart-3: oklch(0.769 0.188 70.08);
+  --chart-4: oklch(0.627 0.265 303.9);
+  --chart-5: oklch(0.645 0.246 16.439);
+  --sidebar: oklch(0.21 0.006 285.885);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.274 0.006 286.033);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.552 0.016 285.938);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+  button:not(:disabled),
+  [role="button"]:not(:disabled) {
+    cursor: pointer;
+  }
+  pre {
+    @apply overflow-auto;
+  }
+  .cm-scroller {
+    @apply scrollbar-thin scrollbar-thumb-muted-foreground/30 dark:scrollbar-thumb-muted-foreground/50 scrollbar-track-transparent !font-mono;
+  }
+  code,
+  kbd,
+  samp,
+  pre {
+    @apply font-mono;
+  }
+
+  /* React Flow Controls */
+  .dark .react-flow__controls {
+    @apply bg-card border border-border shadow-md;
+  }
+
+  .dark .react-flow__controls .react-flow__controls-button {
+    @apply [--xy-controls-button-background-color:transparent] [--xy-controls-button-background-color-hover:var(--accent)] [--xy-controls-button-border-color:var(--border)];
+  }
+
+  /* React Flow Attribution */
+  .dark .react-flow__attribution {
+    @apply [--xy-attribution-background-color:hsl(var(--card)/0.6)];
+  }
+
+  /* Linkbox */
+  [data-slot="linkbox"] {
+    position: relative;
+
+    & a[href]:not([data-slot="linkoverlay"]),
+    abbr[title] {
+      position: relative;
+      z-index: 2;
+    }
+
+    & button {
+      position: relative;
+      z-index: 2;
+      isolation: isolate;
+    }
+  }
+
+  [data-slot="linkoverlay"] {
+    position: static;
+    &::before {
+      content: "";
+      cursor: inherit;
+      display: block;
+      position: absolute;
+      top: 0;
+      left: 0;
+      z-index: 1;
+      width: 100%;
+      height: 100%;
+    }
+  }
+
+  /* UIW CodeMirror */
+
+  .cm-activeLine:has(.cm-placeholder) {
+    @apply !bg-transparent;
+  }
+}

package/src/app/icon.svg

@@ -0,0 +1,5 @@
+<svg width="80" height="80" viewBox="0 0 80 80" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="80" height="80" rx="20" fill="#438CFF"/>
+<path d="M14.7203 40.2201C14.5596 39.9417 14.5597 39.5986 14.7204 39.3202L22.7973 25.3303C22.9581 25.0518 23.2552 24.8803 23.5767 24.8803L39.7308 24.8804C40.0523 24.8804 40.3494 25.0519 40.5102 25.3303L48.5871 39.32C48.7479 39.5984 48.748 39.9417 48.5872 40.2201L40.5102 54.2098C40.3494 54.4883 40.0523 54.6598 39.7307 54.6598L23.5768 54.6599C23.2553 54.6599 22.958 54.4882 22.7973 54.2098L14.7203 40.2201ZM20.8487 55.3348C21.4114 56.3094 22.4514 56.9099 23.5768 56.9099L39.7307 56.9098C40.8561 56.9098 41.896 56.3094 42.4587 55.3348L50.5357 41.3451C51.0984 40.3705 51.0984 39.1696 50.5357 38.195L42.4587 24.2053C41.8961 23.2307 40.8562 22.6304 39.7308 22.6304L23.5767 22.6303C22.4514 22.6303 21.4114 23.2307 20.8487 24.2053L12.7718 38.1952C12.2092 39.1698 12.2091 40.3705 12.7718 41.3451L20.8487 55.3348Z" fill="white"/>
+<path d="M34.2267 47.5751C30.5023 41.8911 31.7972 33.7181 37.4806 29.6753L37.4819 29.6745C39.9058 27.9549 42.9998 25.6703 46.291 24.0563C49.5678 22.4493 53.2377 21.4052 56.8005 22.3839L56.8007 22.3837C58.1072 22.7199 59.1354 23.1789 59.9525 23.8223C60.7797 24.4737 61.3238 25.2616 61.7371 26.1485C62.1385 27.0099 62.4307 27.9995 62.7331 29.0489C63.0417 30.1197 63.3739 31.3038 63.8616 32.6614C64.131 33.4113 64.6726 34.2352 65.3815 35.3425C66.058 36.3992 66.8363 37.6455 67.3841 39.0823C67.9382 40.5357 68.2615 42.1931 68.041 44.0887C67.8211 45.9796 67.068 48.0398 65.5696 50.3153C64.5754 51.825 62.6015 53.3398 60.4882 54.5574C58.3451 55.7921 55.8837 56.8208 53.7681 57.2752L53.7665 57.2754L53.7648 57.2758C49.1794 58.2455 45.4396 57.6404 42.2383 55.8158C39.0777 54.0142 36.5418 51.0796 34.2289 47.5784L34.2278 47.5767L34.2267 47.5751ZM38.7574 31.4729C34.0853 34.7974 32.967 41.6257 36.0686 46.3633L36.0689 46.3631C38.307 49.7511 40.6116 52.3505 43.3304 53.9002C46.0079 55.4263 49.1855 55.9897 53.3051 55.1192L53.4785 55.0808C55.2815 54.6668 57.4495 53.7631 59.3873 52.6466C61.4174 51.4771 63.0236 50.1721 63.728 49.1025C65.0753 47.0565 65.678 45.3197 65.8508 43.8341C66.023 42.3532 65.7761 41.0544 65.3237 39.8678C64.8649 38.6645 64.2003 37.5868 63.5246 36.5312C62.8813 35.5264 62.1612 34.4499 61.7865 33.407C61.2703 31.9701 60.9183 30.7147 60.6143 29.6595C60.3041 28.5829 60.0553 27.7598 59.7385 27.0799C59.4335 26.4255 59.082 25.9435 58.5882 25.5546C58.0842 25.1577 57.3656 24.806 56.2512 24.5192L56.2415 24.5168L56.2318 24.514C53.436 23.74 50.364 24.515 47.2619 26.0362C44.1682 27.5534 41.2416 29.7108 38.7577 31.4729L38.7574 31.4729Z" fill="white"/>
+</svg>

package/src/app/layout.tsx

@@ -0,0 +1,59 @@
+import type { Metadata } from 'next';
+import { Inter, JetBrains_Mono } from 'next/font/google';
+import './globals.css';
+import { NuqsAdapter } from 'nuqs/adapters/next/app';
+import { AppSidebar } from '@/components/sidebar-nav/sidebar-nav';
+import { ThemeProvider } from '@/components/theme-provider';
+import { SidebarInset, SidebarProvider } from '@/components/ui/sidebar';
+import { Toaster } from '@/components/ui/sonner';
+
+const jetBrainsMono = JetBrains_Mono({
+  variable: '--font-jetbrains-mono',
+  subsets: ['latin'],
+});
+
+const inter = Inter({
+  display: 'swap',
+  subsets: ['latin'],
+  variable: '--font-inter',
+});
+
+export const metadata: Metadata = {
+  title: 'Inkeep Agents',
+  description:
+    "Inkeep's multi-agent framework enables multiple specialized AI agents to collaborate and solve complex problems through a graph-based architecture. You can define networks of agents, each with unique instructions, tools, and purposes.",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body className={`${inter.variable} ${jetBrainsMono.variable} antialiased`}>
+        <ThemeProvider
+          attribute="class"
+          defaultTheme="system"
+          enableSystem
+          disableTransitionOnChange
+        >
+          <NuqsAdapter>
+            <SidebarProvider
+              style={
+                {
+                  '--sidebar-width': 'calc(var(--spacing) * 62)',
+                  '--header-height': 'calc(var(--spacing) * 12)',
+                } as React.CSSProperties
+              }
+            >
+              <AppSidebar variant="inset" />
+              <SidebarInset>{children}</SidebarInset>
+            </SidebarProvider>
+            <Toaster />
+          </NuqsAdapter>
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}

package/src/app/page.tsx

@@ -0,0 +1,13 @@
+import { redirectToProject } from '../lib/utils/project-redirect';
+
+const DEFAULT_TENANT_ID = 'default';
+
+async function Home() {
+  if (!process.env.NEXT_PUBLIC_TENANT_ID) {
+    console.warn(`NEXT_PUBLIC_TENANT_ID is not set, using default tenantId: ${DEFAULT_TENANT_ID}`);
+  }
+  const tenantId = process.env.NEXT_PUBLIC_TENANT_ID || DEFAULT_TENANT_ID;
+  await redirectToProject(tenantId, 'graphs');
+}
+
+export default Home;

package/src/app/utils/__tests__/format-date.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { formatDate, formatDateAgo } from '../format-date';
+
+// Mock console.warn to avoid noise in test output
+vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+describe('formatDate', () => {
+  it('should format valid date strings correctly', () => {
+    const result = formatDate('2024-01-15T10:30:00Z');
+    expect(result).toBe('Jan 15, 2024');
+  });
+
+  it('should handle invalid date strings gracefully', () => {
+    const result = formatDate('invalid-date');
+    expect(result).toBe('Invalid date');
+  });
+
+  it('should handle empty string', () => {
+    const result = formatDate('');
+    expect(result).toBe('Invalid date');
+  });
+
+  it('should handle null-like inputs', () => {
+    const result = formatDate('null');
+    expect(result).toBe('Invalid date');
+  });
+});
+
+describe('formatDateAgo', () => {
+  beforeEach(() => {
+    // Mock the current time to make tests deterministic
+    vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
+  });
+
+  describe('valid dates', () => {
+    it('should return "just now" for dates less than 1 minute ago', () => {
+      const thirtySecondsAgo = new Date('2024-01-15T11:59:30Z').toISOString();
+      expect(formatDateAgo(thirtySecondsAgo)).toBe('just now');
+    });
+
+    it('should return minutes for dates less than 1 hour ago', () => {
+      const thirtyMinutesAgo = new Date('2024-01-15T11:30:00Z').toISOString();
+      expect(formatDateAgo(thirtyMinutesAgo)).toBe('30m ago');
+    });
+
+    it('should return hours for dates less than 24 hours ago', () => {
+      const threeHoursAgo = new Date('2024-01-15T09:00:00Z').toISOString();
+      expect(formatDateAgo(threeHoursAgo)).toBe('3h ago');
+    });
+
+    it('should return days for dates less than 7 days ago', () => {
+      const threeDaysAgo = new Date('2024-01-12T12:00:00Z').toISOString();
+      expect(formatDateAgo(threeDaysAgo)).toBe('3d ago');
+    });
+
+    it('should return weeks for dates less than 30 days ago', () => {
+      const twoWeeksAgo = new Date('2024-01-01T12:00:00Z').toISOString();
+      expect(formatDateAgo(twoWeeksAgo)).toBe('2w ago');
+    });
+
+    it('should return formatted date for dates more than 30 days ago (same year)', () => {
+      // Since current mock time is 2024-01-15, we need to use 2023 for dates older than 30 days
+      // Let's change this to test a same year scenario by using a date from later in 2024 as current time
+      vi.setSystemTime(new Date('2024-12-15T12:00:00Z'));
+      const twoMonthsAgo = new Date('2024-09-15T12:00:00Z').toISOString();
+      expect(formatDateAgo(twoMonthsAgo)).toBe('Sep 15');
+      // Reset to original mock time for other tests
+      vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
+    });
+
+    it('should return formatted date with year for dates in different year', () => {
+      const lastYear = new Date('2023-01-15T12:00:00Z').toISOString();
+      expect(formatDateAgo(lastYear)).toBe('Jan 15, 2023');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle future dates', () => {
+      const futureDate = new Date('2024-01-16T12:00:00Z').toISOString();
+      expect(formatDateAgo(futureDate)).toBe('In the future');
+    });
+
+    it('should handle invalid date strings', () => {
+      expect(formatDateAgo('invalid-date')).toBe('Invalid date');
+      // console.warn is not called for invalid dates since they're caught by NaN check, not catch block
+    });
+
+    it('should handle empty string', () => {
+      expect(formatDateAgo('')).toBe('Invalid date');
+    });
+
+    it('should handle null string', () => {
+      expect(formatDateAgo('null')).toBe('Invalid date');
+    });
+
+    it('should handle undefined string', () => {
+      expect(formatDateAgo('undefined')).toBe('Invalid date');
+    });
+
+    it('should handle malformed ISO strings', () => {
+      expect(formatDateAgo('2024-13-45T25:70:80Z')).toBe('Invalid date');
+    });
+
+    it('should handle very large timestamps', () => {
+      const veryOldDate = new Date('1970-01-01T00:00:00Z').toISOString();
+      const result = formatDateAgo(veryOldDate);
+      // The actual result depends on timezone - let's be more flexible
+      expect(result).toMatch(/^(Dec 31, 1969|Jan 1, 1970)$/);
+    });
+  });
+
+  describe('boundary conditions', () => {
+    it('should handle exactly 1 minute ago', () => {
+      const oneMinuteAgo = new Date('2024-01-15T11:59:00Z').toISOString();
+      expect(formatDateAgo(oneMinuteAgo)).toBe('1m ago');
+    });
+
+    it('should handle exactly 1 hour ago', () => {
+      const oneHourAgo = new Date('2024-01-15T11:00:00Z').toISOString();
+      expect(formatDateAgo(oneHourAgo)).toBe('1h ago');
+    });
+
+    it('should handle exactly 1 day ago', () => {
+      const oneDayAgo = new Date('2024-01-14T12:00:00Z').toISOString();
+      expect(formatDateAgo(oneDayAgo)).toBe('1d ago');
+    });
+
+    it('should handle exactly 1 week ago', () => {
+      const oneWeekAgo = new Date('2024-01-08T12:00:00Z').toISOString();
+      expect(formatDateAgo(oneWeekAgo)).toBe('1w ago');
+    });
+  });
+});

package/src/app/utils/active-tools.ts

@@ -0,0 +1,24 @@
+import type { MCPTool } from '@/lib/api/tools';
+
+/**
+ * Gets the active tools for an MCP server.
+ * - If no active tools are configured (undefined), returns all available tools
+ * - If active tools are configured as an array, returns only the tools that are in the active list
+ */
+export function getActiveTools({
+  availableTools,
+  activeTools,
+}: {
+  availableTools: MCPTool['availableTools'];
+  activeTools: MCPTool['config']['mcp']['activeTools'];
+}): MCPTool['availableTools'] | undefined {
+  if (!availableTools) return undefined;
+
+  // If no activeTools configured (undefined), return all available tools
+  if (!activeTools) {
+    return availableTools;
+  }
+
+  // Return filtered tools based on activeTools configuration
+  return availableTools.filter((tool) => activeTools.includes(tool.name));
+}