feat(monitoring): add Threads tab with filters and search

apps/docs/package.json

@@ -22,7 +22,6 @@
   },
   "devDependencies": {
     "@tailwindcss/typography": "^0.5.16",
-    "typescript": "^5.9.3",
     "wrangler": "^4.40.3"
   },
   "engines": {

apps/mesh/src/storage/threads.ts

@@ -67,7 +67,16 @@ export class OrgScopedThreadStorage {
 
   list(
     createdBy?: string,
-    options?: { limit?: number; offset?: number; virtualMcpId?: string },
+    options?: {
+      limit?: number;
+      offset?: number;
+      virtualMcpId?: string;
+      startDate?: string;
+      endDate?: string;
+      search?: string;
+      status?: string;
+      agentId?: string;
+    },
   ): Promise<{ threads: Thread[]; total: number }> {
     return this.inner.list(this.requireOrg(), createdBy, options);
   }
@@ -237,7 +246,16 @@ export class SqlThreadStorage implements ThreadStoragePort {
   async list(
     organizationId: string,
     createdBy?: string,
-    options?: { limit?: number; offset?: number; virtualMcpId?: string },
+    options?: {
+      limit?: number;
+      offset?: number;
+      virtualMcpId?: string;
+      startDate?: string;
+      endDate?: string;
+      search?: string;
+      status?: string;
+      agentId?: string;
+    },
   ): Promise<{ threads: Thread[]; total: number }> {
     let query = this.db
       .selectFrom("threads")
@@ -252,6 +270,30 @@ export class SqlThreadStorage implements ThreadStoragePort {
     if (options?.virtualMcpId) {
       query = query.where("virtual_mcp_id", "=", options.virtualMcpId);
     }
+    if (options?.startDate) {
+      // updated_at is stored as ISO text — string comparison is correct for ISO dates
+      query = query.where(
+        "updated_at",
+        ">=",
+        options.startDate as unknown as Date,
+      );
+    }
+    if (options?.endDate) {
+      query = query.where(
+        "updated_at",
+        "<=",
+        options.endDate as unknown as Date,
+      );
+    }
+    if (options?.search) {
+      query = query.where("title", "ilike", `%${options.search}%`);
+    }
+    if (options?.status) {
+      query = query.where("status", "=", options.status as ThreadStatus);
+    }
+    if (options?.agentId) {
+      query = query.where("virtual_mcp_id", "=", options.agentId);
+    }
 
     let countQuery = this.db
       .selectFrom("threads")
@@ -269,6 +311,33 @@ export class SqlThreadStorage implements ThreadStoragePort {
         options.virtualMcpId,
       );
     }
+    if (options?.startDate) {
+      countQuery = countQuery.where(
+        "updated_at",
+        ">=",
+        options.startDate as unknown as Date,
+      );
+    }
+    if (options?.endDate) {
+      countQuery = countQuery.where(
+        "updated_at",
+        "<=",
+        options.endDate as unknown as Date,
+      );
+    }
+    if (options?.search) {
+      countQuery = countQuery.where("title", "ilike", `%${options.search}%`);
+    }
+    if (options?.status) {
+      countQuery = countQuery.where(
+        "status",
+        "=",
+        options.status as ThreadStatus,
+      );
+    }
+    if (options?.agentId) {
+      countQuery = countQuery.where("virtual_mcp_id", "=", options.agentId);
+    }
 
     if (options?.limit) {
       query = query.limit(options.limit);

apps/mesh/src/tools/thread/list.ts

@@ -23,6 +23,32 @@ const ThreadListInputSchema = CollectionListInputSchema.extend({
       virtual_mcp_id: z.string().optional(),
     })
     .optional(),
+  startDate: z
+    .string()
+    .datetime()
+    .optional()
+    .describe("Filter threads updated at or after this ISO timestamp"),
+  endDate: z
+    .string()
+    .datetime()
+    .optional()
+    .describe("Filter threads updated at or before this ISO timestamp"),
+  search: z
+    .string()
+    .optional()
+    .describe("Full-text search on thread title (case-insensitive)"),
+  status: z
+    .string()
+    .optional()
+    .describe("Filter by thread status (e.g. completed, failed, in_progress)"),
+  userId: z
+    .string()
+    .optional()
+    .describe("Filter by the user who created the thread"),
+  agentId: z
+    .string()
+    .optional()
+    .describe("Filter by agent (connection or virtual MCP) ID"),
 });
 
 /**
@@ -58,7 +84,8 @@ export const COLLECTION_THREADS_LIST = defineTool({
     const virtualMcpId = input.where?.virtual_mcp_id;
     // "me" is a reserved value meaning "filter by the authenticated user"
     const createdBy =
-      input.where?.created_by === "me" ? userId : input.where?.created_by;
+      input.userId ??
+      (input.where?.created_by === "me" ? userId : input.where?.created_by);
 
     const { threads, total } = triggerIds?.length
       ? await ctx.storage.threads.listByTriggerIds(triggerIds, {
@@ -69,6 +96,11 @@ export const COLLECTION_THREADS_LIST = defineTool({
           limit,
           offset,
           virtualMcpId,
+          startDate: input.startDate,
+          endDate: input.endDate,
+          search: input.search,
+          status: input.status,
+          agentId: input.agentId,
         });
 
     const hasMore = offset + limit < total;

apps/mesh/src/tools/thread/schema.ts

@@ -55,6 +55,18 @@ export const ThreadEntitySchema = z.object({
     .string()
     .nullable()
     .describe("User ID who last updated the thread"),
+  virtual_mcp_id: z
+    .string()
+    .optional()
+    .describe("Virtual MCP (agent) this thread was initiated with"),
+  // Typed as a loose record to stay compatible with the Kysely storage type
+  // (Thread.run_config: Record<string, unknown> | null). Callers that need the
+  // typed shape should parse with PersistedRunConfigSchema from run-config.ts.
+  run_config: z
+    .record(z.string(), z.unknown())
+    .nullable()
+    .optional()
+    .describe("Persisted run configuration (contains agent and model info)"),
 });
 
 export type ThreadEntity = z.infer<typeof ThreadEntitySchema>;

apps/mesh/src/web/components/chat/chat-context.tsx

@@ -754,6 +754,10 @@ export function useChatStream(): ChatStreamContextValue {
   return ctx;
 }
 
+export function useOptionalChatStream(): ChatStreamContextValue | null {
+  return useContext(ChatStreamCtx);
+}
+
 export function useChatTask(): ChatTaskContextValue {
   const ctx = useContext(ChatTaskCtx);
   if (!ctx)

apps/mesh/src/web/components/chat/context.tsx

@@ -13,6 +13,7 @@ export {
   ActiveTaskProvider,
   useChatTask,
   useChatStream,
+  useOptionalChatStream,
   useChatPrefs,
   useChatBridge,
   type ChatStreamContextValue,

apps/mesh/src/web/components/chat/message/assistant.tsx

@@ -15,7 +15,7 @@ import {
 import { SmartAutoScroll } from "./smart-auto-scroll.tsx";
 import { type DataParts, useFilterParts } from "./use-filter-parts.ts";
 import { addUsage, emptyUsageStats } from "@decocms/mesh-sdk";
-import { useChatStream } from "../context.tsx";
+import { useOptionalChatStream } from "../context.tsx";
 
 type ThinkingStage = "planning" | "thinking";
 
@@ -374,7 +374,7 @@ export function MessageAssistant({
   className,
   isLast = false,
 }: MessageAssistantProps) {
-  const { isRunInProgress } = useChatStream();
+  const { isRunInProgress = false } = useOptionalChatStream() ?? {};
   const isStreaming = status === "streaming";
   const isSubmitted = status === "submitted";
   const isLoading = isStreaming || isSubmitted;

apps/mesh/src/web/components/monitoring/types.tsx

@@ -92,7 +92,7 @@ export interface MonitoringLogsResponse
 
 export interface MonitoringSearchParams {
   // Tab selection
-  tab?: "overview" | "audit" | "dashboards";
+  tab?: "overview" | "audit" | "dashboards" | "threads";
   // Time range using expressions (from/to)
   from?: string; // e.g., "now-24h", "now-7d", or ISO string
   to?: string; // e.g., "now" or ISO string

apps/mesh/src/web/index.tsx

@@ -277,7 +277,7 @@ const monitoringRoute = createRoute({
   component: lazyRouteComponent(() => import("./routes/orgs/monitoring.tsx")),
   validateSearch: z.lazy(() =>
     z.object({
-      tab: z.enum(["overview", "audit"]).default("overview"),
+      tab: z.enum(["overview", "audit", "threads"]).default("overview"),
       from: z.string().default("now-30m"),
       to: z.string().default("now"),
       connectionId: z.array(z.string()).optional().default([]),

apps/mesh/src/web/lib/query-keys.ts

@@ -159,6 +159,14 @@ export const KEYS = {
   monitoringLogsInfinite: (locator: string, paramsKey: string) =>
     ["monitoring", "logs-infinite", locator, paramsKey] as const,
 
+  // Thread queries (scoped by locator)
+  threadsInfinite: (locator: string, paramsKey: string) =>
+    ["threads", "list-infinite", locator, paramsKey] as const,
+  threadMessages: (locator: string, threadId: string) =>
+    ["threads", "messages", locator, threadId] as const,
+  threadModelLogs: (locator: string, dateKey: string) =>
+    ["threads", "model-logs", locator, dateKey] as const,
+
   // Virtual MCP prompts (for ice breakers in chat)
   // null virtualMcpId means default virtual MCP
   virtualMcpPrompts: (virtualMcpId: string | null, orgId: string) =>