@agent-native/dispatch 0.16.5 → 0.16.6

package/src/actions/read-slack-thread-context.ts

@@ -0,0 +1,171 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { executeProviderApiRequest } from "../server/lib/provider-api.js";
+
+const SlackPermalinkSchema = z
+  .string()
+  .url()
+  .refine((value) => {
+    const url = new URL(value);
+    return (
+      url.protocol === "https:" &&
+      url.hostname.endsWith(".slack.com") &&
+      url.pathname.startsWith("/archives/")
+    );
+  }, "Expected an https Slack archive permalink.")
+  .describe("Slack message permalink from the issue or feedback report.");
+
+type SlackMessage = {
+  ts?: string;
+  thread_ts?: string;
+  user?: string;
+  username?: string;
+  bot_id?: string;
+  text?: string;
+  blocks?: unknown;
+  attachments?: unknown;
+  files?: unknown;
+  reactions?: unknown;
+};
+
+function parseSlackPermalink(permalink: string) {
+  const url = new URL(permalink);
+  const match = url.pathname.match(/^\/archives\/([^/]+)\/p(\d{16})$/);
+  if (!match) {
+    throw new Error(
+      "Slack permalink must include a channel id and 16-digit message timestamp.",
+    );
+  }
+
+  const [, channelId, compactTimestamp] = match;
+  const linkedMessageTs = `${compactTimestamp.slice(0, 10)}.${compactTimestamp.slice(10)}`;
+  const threadTs = url.searchParams.get("thread_ts") || linkedMessageTs;
+
+  return { channelId, linkedMessageTs, threadTs };
+}
+
+function getResponseJson(response: unknown): Record<string, unknown> {
+  if (!response || typeof response !== "object") {
+    throw new Error("Slack thread read returned no response metadata.");
+  }
+
+  const value = response as { json?: unknown; status?: number; ok?: boolean };
+  if (value.ok !== true) {
+    throw new Error(
+      `Slack thread read failed with HTTP ${value.status ?? "unknown"}.`,
+    );
+  }
+  if (!value.json || typeof value.json !== "object") {
+    throw new Error("Slack thread read returned no JSON body.");
+  }
+
+  const body = value.json as Record<string, unknown>;
+  if (body.ok !== true) {
+    const error = typeof body.error === "string" ? body.error : "unknown_error";
+    throw new Error(`Slack thread read failed: ${error}.`);
+  }
+  return body;
+}
+
+function collectLinks(value: unknown, links: Set<string>): void {
+  if (typeof value === "string") {
+    for (const match of value.matchAll(/https?:\/\/[^\s<>|]+/g)) {
+      links.add(match[0].replace(/[),.;]+$/, ""));
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectLinks(item, links);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "url" && typeof child === "string") links.add(child);
+    else collectLinks(child, links);
+  }
+}
+
+function projectMessage(message: SlackMessage) {
+  return {
+    ts: message.ts ?? null,
+    threadTs: message.thread_ts ?? null,
+    user: message.user ?? null,
+    username: message.username ?? null,
+    botId: message.bot_id ?? null,
+    text: message.text ?? "",
+    ...(message.blocks ? { blocks: message.blocks } : {}),
+    ...(message.attachments ? { attachments: message.attachments } : {}),
+    ...(message.files ? { files: message.files } : {}),
+    ...(message.reactions ? { reactions: message.reactions } : {}),
+  };
+}
+
+export default defineAction({
+  description:
+    "Read the complete Slack thread behind an issue permalink before diagnosing or fixing it. Resolves a child permalink to its parent, returns messages plus attachments and related links, and reports pagination completeness. Read-only; never joins a channel or sends a message.",
+  schema: z.object({
+    permalink: SlackPermalinkSchema,
+    limit: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(1000)
+      .default(100)
+      .describe("Maximum Slack messages to return in this page."),
+    cursor: z
+      .string()
+      .optional()
+      .describe("Slack response_metadata.next_cursor from a previous page."),
+    connectionId: z
+      .string()
+      .optional()
+      .describe(
+        "Optional connected Slack workspace id when several are granted.",
+      ),
+  }),
+  http: false,
+  readOnly: true,
+  run: async ({ permalink, limit, cursor, connectionId }) => {
+    const parsed = parseSlackPermalink(permalink);
+    const result = await executeProviderApiRequest({
+      provider: "slack",
+      method: "GET",
+      path: "/conversations.replies",
+      query: {
+        channel: parsed.channelId,
+        ts: parsed.threadTs,
+        limit,
+        ...(cursor ? { cursor } : {}),
+      },
+      connectionId,
+      maxBytes: 2 * 1024 * 1024,
+    });
+
+    const response = (result as { response?: unknown }).response;
+    const body = getResponseJson(response);
+    const messages = Array.isArray(body.messages)
+      ? (body.messages as SlackMessage[])
+      : [];
+    const nextCursor =
+      body.response_metadata && typeof body.response_metadata === "object"
+        ? (body.response_metadata as { next_cursor?: unknown }).next_cursor
+        : null;
+    const relatedLinks = new Set<string>();
+    collectLinks(messages, relatedLinks);
+
+    return {
+      permalink,
+      channelId: parsed.channelId,
+      linkedMessageTs: parsed.linkedMessageTs,
+      threadTs: parsed.threadTs,
+      messages: messages.map(projectMessage),
+      messageCount: messages.length,
+      completeness: nextCursor ? "partial" : "complete",
+      nextCursor:
+        typeof nextCursor === "string" && nextCursor ? nextCursor : null,
+      relatedLinks: [...relatedLinks],
+    };
+  },
+});

package/src/components/layout/Layout.tsx

@@ -654,13 +654,17 @@ export function NavContent({
                 src={appPath("/agent-native-icon-light.svg")}
                 alt=""
                 aria-hidden="true"
-                className="block h-5 w-auto shrink-0 dark:hidden"
+                width={35}
+                height={20}
+                className="block h-5 w-[35px] shrink-0 object-contain object-center dark:hidden"
               />
               <img
                 src={appPath("/agent-native-icon-dark.svg")}
                 alt=""
                 aria-hidden="true"
-                className="hidden h-5 w-auto shrink-0 dark:block"
+                width={35}
+                height={20}
+                className="hidden h-5 w-[35px] shrink-0 object-contain object-center dark:block"
               />
               <div className="min-w-0 flex-1">
                 <div className="truncate text-lg font-bold tracking-tight text-foreground">

package/src/server/lib/thread-debug-store.spec.ts

@@ -182,6 +182,66 @@ describe("thread-debug-store", () => {
     });
   });
 
+  it("separates interactive and scheduled populations and attaches the measured taxonomy", async () => {
+    mocks.currentExecute.mockImplementation(async ({ sql }) => {
+      if (!sql.includes("JOIN chat_threads")) return { rows: [] };
+      if (sql.includes("r.id NOT LIKE 'job-%'")) {
+        return {
+          rows: [
+            failureRow("run-interactive", Date.now(), {
+              error_code: null,
+              error_detail: "Missing Authentication header",
+              terminal_reason: null,
+            }),
+          ],
+        };
+      }
+      if (sql.includes("r.id LIKE 'job-%'")) {
+        return {
+          rows: [
+            failureRow("job-analytics-1", Date.now(), {
+              error_code: null,
+              error_detail:
+                '{"error":{"type":"overloaded_error","message":"Overloaded"}}',
+              terminal_reason: null,
+            }),
+          ],
+        };
+      }
+      return [];
+    });
+
+    const interactive = await listAgentRunFailures({
+      sourceId: "current",
+      regime: "interactive",
+    });
+    const scheduled = await listAgentRunFailures({
+      sourceId: "current",
+      regime: "scheduled",
+    });
+
+    expect(interactive).toMatchObject({
+      regime: "interactive",
+      failures: [
+        {
+          id: "run-interactive",
+          regime: "interactive",
+          failureTaxonomy: { code: "authentication_error" },
+        },
+      ],
+    });
+    expect(scheduled).toMatchObject({
+      regime: "scheduled",
+      failures: [
+        {
+          id: "job-analytics-1",
+          regime: "scheduled",
+          failureTaxonomy: { code: "overloaded_error" },
+        },
+      ],
+    });
+  });
+
   it("merges all admin-visible sources, sorts globally, limits, and preserves partial health", async () => {
     vi.stubEnv("DISPATCH_ADMIN_EMAILS", "owner@example.com");
     vi.stubEnv("REMOTE_A_DATABASE_URL", "libsql://remote-a");

package/src/server/lib/thread-debug-store.ts

@@ -1,3 +1,7 @@
+import {
+  classifyAgentFailure,
+  type AgentFailureRegime,
+} from "@agent-native/core/agent/engine";
 import { createDbExec, getDbExec, type DbExec } from "@agent-native/core/db";
 
 import { currentOrgId, currentOwnerEmail } from "./dispatch-store.js";
@@ -652,6 +656,14 @@ function serializeRunFailure(
 ) {
   const startedAt = numberField(row.started_at);
   const completedAt = nullableNumberField(row.completed_at);
+  const terminalEvent = parseTerminalEvent(row.debug_terminal_event_data);
+  const failureTaxonomy = classifyAgentFailure({
+    runId: row.id,
+    errorCode: row.error_code,
+    errorDetail: row.error_detail,
+    terminalReason: row.terminal_reason,
+    terminalEvent,
+  });
   return {
     source: publicSource(source),
     id: String(row.id),
@@ -674,7 +686,9 @@ function serializeRunFailure(
     workerStage: row.worker_stage ? String(row.worker_stage) : null,
     diagStage: row.diag_stage ? String(row.diag_stage) : null,
     peakRssMb: nullableNumberField(row.peak_rss_mb),
-    terminalEvent: parseTerminalEvent(row.debug_terminal_event_data),
+    terminalEvent,
+    regime: failureTaxonomy.regime,
+    failureTaxonomy,
   };
 }
 
@@ -701,6 +715,7 @@ async function failuresForSource(
   scope: OwnerScope,
   input: {
     status: AgentRunFailureStatus | "all";
+    regime: AgentFailureRegime | "all";
     cutoff: number;
     limit: number;
   },
@@ -709,6 +724,12 @@ async function failuresForSource(
   const statuses =
     input.status === "all" ? [...UNSUCCESSFUL_RUN_STATUSES] : [input.status];
   const statusPlaceholders = statuses.map(() => "?").join(", ");
+  const regimeClause =
+    input.regime === "scheduled"
+      ? "AND r.id LIKE 'job-%'"
+      : input.regime === "interactive"
+        ? "AND r.id NOT LIKE 'job-%'"
+        : "";
   const rows = await queryRows<AgentRunFailureRow>(
     exec,
     `SELECT r.*,
@@ -726,6 +747,7 @@ async function failuresForSource(
        JOIN chat_threads t ON t.id = r.thread_id
       WHERE r.status IN (${statusPlaceholders})
         AND ${scope.sql}
+        ${regimeClause}
         AND COALESCE(r.completed_at, r.started_at) >= ?
       ORDER BY COALESCE(r.completed_at, r.started_at) DESC, r.id DESC
       LIMIT ?`,
@@ -738,12 +760,14 @@ export async function listAgentRunFailures(input: {
   sourceId?: string;
   ownerEmail?: string;
   status?: AgentRunFailureStatus | "all";
+  regime?: AgentFailureRegime | "all";
   lookbackHours?: number;
   limit?: number;
 }) {
   const access = await resolveDebugAccess();
   const requestedSourceId = input.sourceId?.trim() || "all";
   const status = input.status ?? "all";
+  const regime = input.regime ?? "all";
   const lookbackHours = Math.max(1, Math.min(720, input.lookbackHours ?? 168));
   const limit = Math.max(1, Math.min(100, input.limit ?? DEFAULT_SEARCH_LIMIT));
   const scope = ownerScope(access, input.ownerEmail, "t.owner_email");
@@ -784,6 +808,7 @@ export async function listAgentRunFailures(input: {
       try {
         const failures = await failuresForSource(source, scope, {
           status,
+          regime,
           cutoff,
           limit,
         });
@@ -829,6 +854,7 @@ export async function listAgentRunFailures(input: {
   return {
     sourceId: requestedSourceId,
     status,
+    regime,
     lookbackHours,
     limit,
     count: failures.length,