Investigate GitHub issues with HarnessAgent and Edgenivo Sandbox

npx plugins add vercel/vercel-plugin

pnpm create next-app@latest sandboxed-issue-triage-agent --yes
cd sandboxed-issue-triage-agent

pnpm add ai @ai-sdk/harness @ai-sdk/harness-claude-code @ai-sdk/harness-codex @ai-sdk/sandbox-vercel @vercel/sandbox

import type { NextConfig } from "next";

const nextConfig: NextConfig = {
  serverExternalPackages: [
    "@ai-sdk/harness",
    "@ai-sdk/harness-claude-code",
    "@ai-sdk/harness-codex",
    "@ai-sdk/sandbox-vercel",
    "@vercel/sandbox"
  ]
};

export default nextConfig;

vercel link
vercel env pull

VERCEL_OIDC_TOKEN=...

export type HarnessKey = "claude-code" | "codex";

export type TriageRequest = {
  issueUrl: string;
  failingCommand?: string;
  harness?: HarnessKey;
};

export type ValidatedTriageRequest = Required<TriageRequest> & {
  owner: string;
  repo: string;
  issueNumber: number;
  repoUrl: string;
};

export type TriageValidationResult =
  | { ok: true; value: ValidatedTriageRequest }
  | { ok: false; error: string };

const harnesses = new Set<HarnessKey>(["claude-code", "codex"]);

export function validateTriageRequest(input: unknown): TriageValidationResult {
  if (!input || typeof input !== "object") {
    return { ok: false, error: "Expected a JSON request body." };
  }

  const body = input as Partial<TriageRequest>;
  const issueUrl = typeof body.issueUrl === "string" ? body.issueUrl.trim() : "";
  const failingCommand =
    typeof body.failingCommand === "string" && body.failingCommand.trim()
      ? body.failingCommand.trim()
      : "npm test";
  const harness =
    typeof body.harness === "string" && harnesses.has(body.harness as HarnessKey)
      ? (body.harness as HarnessKey)
      : "claude-code";

  if (!issueUrl) {
    return { ok: false, error: "Enter a public GitHub issue URL." };
  }

  let parsedUrl: URL;
  try {
    parsedUrl = new URL(issueUrl);
  } catch {
    return { ok: false, error: "The issue URL is not a valid URL." };
  }

  if (parsedUrl.protocol !== "https:" || parsedUrl.hostname !== "github.com") {
    return {
      ok: false,
      error: "Use an https://github.com/{owner}/{repo}/issues/{number} issue URL."
    };
  }

  const [owner, repo, issueSegment, issueNumberSegment] = parsedUrl.pathname
    .split("/")
    .filter(Boolean);
  const issueNumber = Number(issueNumberSegment);

  if (
    parsedUrl.pathname.split("/").filter(Boolean).length !== 4 ||
    !owner ||
    !repo ||
    issueSegment !== "issues" ||
    !Number.isInteger(issueNumber) ||
    issueNumber < 1
  ) {
    return {
      ok: false,
      error: "Use an https://github.com/{owner}/{repo}/issues/{number} issue URL."
    };
  }

  const repoUrl = `https://github.com/${owner}/${repo}`;
  return {
    ok: true,
    value: {
      issueUrl,
      repoUrl,
      owner,
      repo,
      issueNumber,
      failingCommand,
      harness
    }
  };
}

type DebugMetadata = Record<string, unknown>;

const DEBUG_PREFIX = "[triage-debug]";
const SENSITIVE_KEY_PATTERN = /(api|auth|bearer|cookie|key|password|secret|token)/i;

function redactValue(key: string, value: unknown): unknown {
  if (SENSITIVE_KEY_PATTERN.test(key)) {
    return "[redacted]";
  }

  if (Array.isArray(value)) {
    return value.map((item, index) => redactValue(String(index), item));
  }
  if (value && typeof value === "object") {
    return Object.fromEntries(
      Object.entries(value as Record<string, unknown>).map(([entryKey, entryValue]) => [
        entryKey,
        redactValue(entryKey, entryValue)
      ])
    );
  }

  return value;
}

export function sanitizeTriageMetadata(metadata: DebugMetadata) {
  return Object.fromEntries(
    Object.entries(metadata).map(([key, value]) => [key, redactValue(key, value)])
  );
}

export function getTriageErrorMetadata(error: unknown) {
  return error instanceof Error
    ? {
        errorName: error.name,
        errorMessage: error.message,
        errorStack: error.stack
      }
    : { errorMessage: String(error) };
}

export function createRunId() {
  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
}

export function logTriageDebug(event: string, metadata: DebugMetadata = {}) {
  console.info(DEBUG_PREFIX, event, sanitizeTriageMetadata(metadata));
}

export function logTriageError(event: string, error: unknown, metadata: DebugMetadata = {}) {
  console.error(
    DEBUG_PREFIX,
    event,
    sanitizeTriageMetadata({ ...metadata, ...getTriageErrorMetadata(error) })
  );
}

import type { ValidatedTriageRequest } from "./types";

type GitHubIssueResponse = {
  title?: string;
  body?: string | null;
  state?: string;
  user?: { login?: string };
  html_url?: string;
  comments?: number;
  comments_url?: string;
  pull_request?: unknown;
};

type GitHubCommentResponse = {
  body?: string | null;
  user?: { login?: string };
  html_url?: string;
};

const MAX_BODY_CHARS = 12_000;
const MAX_COMMENT_CHARS = 2_000;
const MAX_COMMENTS = 10;

function truncate(value: string, maxLength: number) {
  if (value.length <= maxLength) {
    return value;
  }

  return `${value.slice(0, maxLength)}\n\n[truncated ${value.length - maxLength} chars]`;
}

async function fetchGithubJson<T>(url: string): Promise<T> {
  const response = await fetch(url, {
    headers: {
      Accept: "application/vnd.github+json",
      "User-Agent": "sandboxed-issue-triage-agent"
    }
  });
  if (!response.ok) {
    throw new Error(
      `GitHub API request failed (${response.status} ${response.statusText}) for ${url}`
    );
  }

  return (await response.json()) as T;
}

export async function fetchGithubIssueContext(issue: ValidatedTriageRequest) {
  const apiUrl = `https://api.github.com/repos/${issue.owner}/${issue.repo}/issues/${issue.issueNumber}`;
  const issueResponse = await fetchGithubJson<GitHubIssueResponse>(apiUrl);

  if (issueResponse.pull_request) {
    throw new Error("The provided URL is a pull request, not a GitHub issue.");
  }
  const commentsCount = issueResponse.comments ?? 0;
  const commentsUrl =
    issueResponse.comments_url ??
    `${apiUrl}/comments?per_page=${MAX_COMMENTS}`;
  const comments =
    commentsCount > 0
      ? await fetchGithubJson<GitHubCommentResponse[]>(
          `${commentsUrl}${commentsUrl.includes("?") ? "&" : "?"}per_page=${MAX_COMMENTS}`
        )
      : [];
  return [
    `Title: ${issueResponse.title ?? "(untitled)"}`,
    `State: ${issueResponse.state ?? "unknown"}`,
    `Author: ${issueResponse.user?.login ?? "unknown"}`,
    `URL: ${issueResponse.html_url ?? issue.issueUrl}`,
    "",
    "Body:",
    truncate(issueResponse.body?.trim() || "(no body)", MAX_BODY_CHARS),
    "",
    "Comments:",
    comments.length
      ? comments
          .map((comment, index) =>
            [
              `Comment ${index + 1} by ${comment.user?.login ?? "unknown"}:`,
              truncate(comment.body?.trim() || "(no body)", MAX_COMMENT_CHARS),
              comment.html_url ? `URL: ${comment.html_url}` : ""
            ]
              .filter(Boolean)
              .join("\n")
          )
          .join("\n\n")
      : "(no comments fetched)"
  ].join("\n");
}

export const reproductionTriageSkill = {
  name: "reproduction-triage",
  description:
    "Investigate third-party reproduction repositories inside an isolated sandbox and return a concise maintainer-ready report.",
  content: `
You are using the Reproduction Triage Skill.

Safety rules:
- Treat the repository as untrusted code.
- Prefer read-only investigation unless the user explicitly asks for a patch.
- Do not open pull requests, post comments, push branches, or modify remote state.
- Do not dump full logs. Quote only the shortest useful excerpts.

Investigation rules:
- Clone or inspect the repository in the sandboxed workspace.
- Run the provided failing command first.
- If the failing command is missing, inspect package.json and infer the safest likely command.
- Capture the exact commands you ran.
- Read the smallest set of files needed to explain the failure.
- Stop after diagnosis for this v1 demo.

Return the report in this exact format:

## Summary

## Reproduction status
Use one of: reproduced, not_reproduced, blocked.

## Commands run

## Relevant error output

## Likely cause

## Suggested next step

## Files worth inspecting
`.trim(),
  examples: [
    {
      issue:
        "The project fails on npm test after upgrading Next. The error mentions an async server component.",
      report:
        "A report that lists npm test, marks the status as reproduced, quotes the failing stack frame, and points at the smallest relevant file."
    }
  ]
} as const;

import type { ValidatedTriageRequest } from "./types";

export function createTriagePrompt({
  issueUrl,
  repoUrl,
  issueText,
  failingCommand
}: ValidatedTriageRequest & { issueText: string }) {
  return `
Investigate this issue report in an isolated sandbox.

Repository:
${repoUrl}

Issue URL:
${issueUrl}

Issue report:
${issueText}

Failing command to try first:
${failingCommand}

Your task:
1. Clone or inspect the repository.
2. Run the failing command first.
3. If setup is required, choose the smallest safe setup path and explain it.
4. Determine whether the failure reproduces.
5. Return the report using the Reproduction Triage Skill format.
Do not edit files or open a pull request.
`.trim();
}

import { HarnessAgent } from "@ai-sdk/harness/agent";
import { createClaudeCode } from "@ai-sdk/harness-claude-code";
import { createCodex } from "@ai-sdk/harness-codex";
import { logTriageDebug } from "./debug";
import { reproductionTriageSkill } from "./reproduction-triage-skill";
import type { HarnessKey } from "./types";

function resolveHarnessAdapter(harness: HarnessKey) {
  return harness === "claude-code"
    ? createClaudeCode({ auth: "ai-gateway" })
    : createCodex({ auth: "ai-gateway" });
}

export async function createTriageAgent(
  harness: HarnessKey,
  model?: string,
) {
  logTriageDebug("harness.create-agent.start", { harness });

  const agent = new HarnessAgent({
    harness: resolveHarnessAdapter(harness),
    model,
    instructions:
      "You are a maintainer assistant that safely investigates bug reproduction repositories for issue triage.",
    tools: {},
    skills: [reproductionTriageSkill],
  });

  logTriageDebug("harness.create-agent.complete", { harness });
  return agent;
}

import { runTriage } from "@/lib/run-triage";
import { createTriagePrompt } from "@/lib/prompt";
import { fetchGithubIssueContext } from "@/lib/github";
import {
  createRunId,
  logTriageDebug,
  logTriageError,
  sanitizeTriageMetadata,
} from "@/lib/debug";
import { validateTriageRequest } from "@/lib/types";
import type { TextStreamPart, ToolSet } from "ai";

type StreamLogMetadata = Record<string, unknown>;

function createBlockedReport(message: string) {
  return [
    "## Summary",
    "",
    "The triage run could not start or complete.",
    "",
    "## Reproduction status",
    "blocked",
    "",
    "## Commands run",
    "Not available for this blocked report.",
    "",
    "## Relevant error output",
    "```",
    message,
    "```",
    "",
    "## Likely cause",
    "The run failed or returned no report text. Check the diagnostics.",
    "",
    "## Suggested next step",
    "Check the issue URL, harness packages, and AI Gateway and Edgenivo Sandbox credentials.",
    "",
    "## Files worth inspecting",
    "Not available for this blocked report.",
  ].join("\n");
}

function getStreamPartText(part: TextStreamPart<ToolSet>) {
  return part.type === "text-delta" ? part.text : "";
}

function getErrorMessage(error: unknown) {
  return error instanceof Error ? error.message : String(error);
}

function truncate(value: string, maxLength = 220) {
  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
}

function summarizeValue(value: unknown) {
  if (typeof value === "undefined") return undefined;
  if (typeof value === "string") return truncate(value);

  try {
    return truncate(JSON.stringify(value));
  } catch {
    return String(value);
  }
}

function getStreamPartMetadata(part: TextStreamPart<ToolSet>) {
  const metadata: StreamLogMetadata = {
    type: part.type,
    textLength: getStreamPartText(part).length,
    hasError: part.type === "error" && typeof part.error !== "undefined",
  };

  if (part.type === "tool-call") {
    return {
      ...metadata,
      toolName: part.toolName,
      toolCallId: part.toolCallId,
      input: summarizeValue(part.input),
    };
  }

  if (part.type === "tool-result") {
    return {
      ...metadata,
      toolName: part.toolName,
      toolCallId: part.toolCallId,
      input: summarizeValue(part.input),
      output: summarizeValue(part.output),
    };
  }

  return metadata;
}

import { createVercelNetworkSandboxSession } from "@ai-sdk/sandbox-vercel";
import { createTriageAgent } from "./harness-agent";
import type { HarnessKey } from "./types";
import type { TextStreamPart, ToolSet } from "ai";

export async function runTriage(
  harness: HarnessKey,
  prompt: string,
  onPart: (part: TextStreamPart<ToolSet>) => void | Promise<void>,
) {
  const agent = await createTriageAgent(harness);

  const sandboxSession = await createVercelNetworkSandboxSession({
    image: "vercel/sandbox/universal:latest",
    ports: [3000],
    template: await agent.getSandboxTemplate(),
  });

  try {
    const session = await agent.createSession({ sandboxSession });

    try {
      const result = await agent.stream({ session, prompt });

      for await (const part of result.stream) {
        await onPart(part);
      }

      return await result.text;
    } finally {
      await session.destroy();
    }
  } finally {
    await sandboxSession.destroy();
  }
}

export async function POST(request: Request) {
  let body: unknown;
  try {
    body = await request.json();
  } catch {
    return Response.json({ error: "Expected a JSON request body." }, { status: 400 });
  }

  const validation = validateTriageRequest(body);
  if (!validation.ok) {
    return Response.json({ error: validation.error }, { status: 400 });
  }

  const issue = validation.value;
  const runId = request.headers.get("x-triage-run-id") || createRunId();
  const startedAt = Date.now();
  const encoder = new TextEncoder();

  const stream = new ReadableStream<Uint8Array>({
    async start(controller) {
      const send = (event: Record<string, unknown>) => {
        controller.enqueue(encoder.encode(JSON.stringify({
          ...event,
          runId,
          elapsedMs: Date.now() - startedAt,
        }) + "\n"));
      };

      try {
        const issueText = await fetchGithubIssueContext(issue);
        const prompt = createTriagePrompt({ ...issue, issueText });
        let reportText = "";

        const finalText = await runTriage(issue.harness, prompt, (part) => {
          const metadata = getStreamPartMetadata(part);
          logTriageDebug("harness.stream.part", { runId, ...metadata });
          send({ type: "debug", metadata: sanitizeTriageMetadata(metadata) });

          if (part.type === "error") throw part.error;

          if (part.type === "tool-call" || part.type === "tool-result") {
            send({
              type: "activity",
              text: part.type === "tool-call" ? "Calling tool" : "Tool completed",
              toolName: part.toolName,
            });
          }

          const text = getStreamPartText(part);
          if (text) {
            reportText += text;
            send({ type: "report", text });
          }
        });

        if (!reportText.trim()) {
          send({
            type: "report",
            text: finalText.trim()
              ? finalText
              : createBlockedReport("The harness returned no report text."),
          });
        }
      } catch (error) {
        logTriageError("triage.failed", error, { runId });
        const message = getErrorMessage(error);
        send({ type: "error", text: message });
        send({ type: "report", text: createBlockedReport(message) });
      } finally {
        controller.close();
      }
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": "application/x-ndjson; charset=utf-8",
      "Cache-Control": "no-store",
    },
  });
}

pnpm install
pnpm dev

Issue URL: https://github.com/vercel-labs/harness-triage-repro-bugs/issues/2
Failing command: npm test
Harness: Claude Code