@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-fix-retry/fix-retry.js

@@ -0,0 +1,304 @@
+import { performance } from 'node:perf_hooks';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { repositoryKey } from 'doistbot-issue-routing';
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { recordTaskMetrics } from '../../core/datadog-metrics.js';
+import { githubHistoryIdentity } from '../../core/github-history.js';
+import { logger } from '../../core/logging.js';
+import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
+import { resolveIssueRepositories } from '../../core/repository-resolver.js';
+import { recordDecision, withPhase } from '../../core/tracing.js';
+import { shutdownTracing } from '../../core/tracing-setup.js';
+import { parseIssueTriageContext } from '../issue-triage/context.js';
+import { postAutoFixFailureComment } from '../issue-triage/fix-attempt.js';
+import { runConfiguredFix } from '../issue-triage/fix-dispatch.js';
+import { parseFixAssessment } from '../issue-triage/output.js';
+import { readTriageReport, reportAssessment, reportForFix } from '../issue-triage/report.js';
+import { cloneRepository, createGitHubClients, extractLabelNames, fetchIssue, fetchIssueComments, getIssueUrl, prepareWorkspaceReposDirectory, TRIAGE_MARKER, } from '../issue-triage/shared.js';
+export async function main() {
+    const startedAt = performance.now();
+    const ctx = parseIssueTriageContext();
+    let exitCode = 0;
+    let metricOutcome = 'failure';
+    let metricRepository = `${ctx.owner}/${ctx.repo}`;
+    logger.setBaseContext({
+        deliveryId: ctx.deliveryId,
+        repository: `${ctx.owner}/${ctx.repo}`,
+        issueNumber: ctx.issueNumber,
+    });
+    // Keep manual command metrics under the retry task while the shared loop runs.
+    await withPhase('issue-fix-retry', {
+        task: 'issue-fix-retry',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.issue-fix-retry',
+        'issue.number': ctx.issueNumber,
+        'comment.id': ctx.commentId,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        async function postComment(body) {
+            if (ctx.dryRun)
+                return;
+            await writeOctokit.rest.issues.createComment({
+                owner: ctx.owner,
+                repo: ctx.repo,
+                issue_number: ctx.issueNumber,
+                body,
+            });
+        }
+        try {
+            const [issue, comments] = await Promise.all([
+                fetchIssue(readOctokit, ctx),
+                fetchIssueComments(readOctokit, ctx),
+            ]);
+            // Find the most recent triage comment from the bot (search backwards to get the latest one)
+            let triageComment;
+            for (let i = comments.length - 1; i >= 0; i--) {
+                const comment = comments[i];
+                if (comment &&
+                    isKnownDoistbotLogin(comment.user?.login) &&
+                    comment.body?.includes(TRIAGE_MARKER)) {
+                    triageComment = comment;
+                    break;
+                }
+            }
+            if (!triageComment?.body) {
+                // User-actionable (no prior triage), not a malfunction → span stays ok.
+                logger.warn('No triage comment found for fix retry', {
+                    task: 'issue-fix-retry',
+                    issueNumber: ctx.issueNumber,
+                });
+                await postComment('No previous triage found on this issue. Run `@doistbot /triage` first, then retry with `@doistbot /fix`.');
+                return;
+            }
+            // Strip the triage marker to get the raw triage output
+            const commentOutput = triageComment.body.replace(TRIAGE_MARKER, '').trim();
+            let report;
+            let fixAssessment;
+            try {
+                report = readTriageReport(commentOutput);
+                fixAssessment = report
+                    ? reportAssessment(report)
+                    : parseFixAssessment(commentOutput);
+            }
+            catch {
+                report = null;
+                fixAssessment = null;
+            }
+            if (!fixAssessment) {
+                logger.warn('No fix assessment found in triage output', {
+                    task: 'issue-fix-retry',
+                    issueNumber: ctx.issueNumber,
+                });
+                await postComment('The previous triage has no valid fix assessment. Run `@doistbot /triage` again before requesting a fix.');
+                return;
+            }
+            if (report &&
+                githubHistoryIdentity(report.issueUrl) !==
+                    githubHistoryIdentity(getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber))) {
+                await postComment('The stored triage report belongs to another issue. Run `@doistbot /triage` again.');
+                return;
+            }
+            if (report &&
+                fixAssessment.classification !== 'auto-fixable' &&
+                fixAssessment.classification !== 'logs-needed') {
+                await postComment('The latest triage needs more evidence or human input. Address its next steps and run `@doistbot /triage` again.');
+                return;
+            }
+            const triageOutput = report ? reportForFix(report) : commentOutput;
+            if (fixAssessment.targetRepo) {
+                metricRepository = fixAssessment.targetRepo;
+            }
+            logger.info('Fix assessment found from previous triage', {
+                task: 'issue-fix-retry',
+                issueNumber: ctx.issueNumber,
+                classification: fixAssessment.classification,
+                confidence: fixAssessment.confidence,
+                scope: fixAssessment.scope,
+            });
+            // Resolve repositories to clone. Prefer the target repo from the assessment
+            // (stable across label changes) and fall back to label-based resolution.
+            const reposDir = prepareWorkspaceReposDirectory();
+            const clonedRepositories = [];
+            if (fixAssessment.targetRepo) {
+                const resolution = resolveIssueRepositories(extractLabelNames(issue.labels));
+                const repoTarget = resolution.status === 'resolved'
+                    ? resolution.repositories.find((r) => repositoryKey(r.fullName) ===
+                        repositoryKey(fixAssessment.targetRepo))
+                    : undefined;
+                if (repoTarget) {
+                    try {
+                        const cloneResult = await cloneRepository({
+                            app,
+                            repository: repoTarget,
+                            reposDir,
+                            fallbackInstallationId: ctx.installationId,
+                        });
+                        clonedRepositories.push(cloneResult);
+                        metricRepository = cloneResult.repository.fullName;
+                    }
+                    catch (error) {
+                        logger.warn('Fix retry clone failed for assessment target repo', {
+                            task: 'issue-fix-retry',
+                            repository: fixAssessment.targetRepo,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+            // Fall back to label-based resolution if the assessment target wasn't cloned
+            if (clonedRepositories.length === 0) {
+                const labelNames = extractLabelNames(issue.labels);
+                const resolution = resolveIssueRepositories(labelNames);
+                if (resolution.status === 'unresolved') {
+                    // User-actionable (labels don't map to a repo) → span stays ok.
+                    logger.warn('Fix retry failed: could not resolve repositories from labels', {
+                        task: 'issue-fix-retry',
+                        issueNumber: ctx.issueNumber,
+                        reason: resolution.reason,
+                    });
+                    await postComment(`Could not resolve target repositories from the issue labels. Please check the labels and try again.\n\nReason: ${resolution.reason}`);
+                    return;
+                }
+                if (resolution.repositories.length === 1) {
+                    metricRepository = resolution.repositories[0].fullName;
+                }
+                for (const repository of resolution.repositories) {
+                    try {
+                        const cloneResult = await cloneRepository({
+                            app,
+                            repository,
+                            reposDir,
+                            fallbackInstallationId: ctx.installationId,
+                        });
+                        clonedRepositories.push(cloneResult);
+                    }
+                    catch (error) {
+                        logger.warn('Fix retry clone failed', {
+                            task: 'issue-fix-retry',
+                            repository: repository.fullName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+            if (clonedRepositories.length === 0) {
+                // Infrastructure failure → mark the run failed.
+                const message = 'Fix retry failed: all repository clones failed';
+                logger.error(message, {
+                    task: 'issue-fix-retry',
+                    issueNumber: ctx.issueNumber,
+                });
+                span.setStatus({ code: SpanStatusCode.ERROR, message });
+                await postComment('Fix retry failed — could not clone the target repositories. Please try again later.');
+                return;
+            }
+            const issueInstallationAuth = (await app.octokit.auth({
+                type: 'installation',
+                installationId: ctx.installationId,
+            }));
+            const fixResult = await runConfiguredFix({
+                ctx,
+                octokit: writeOctokit,
+                triageOutput,
+                fixAssessment,
+                clonedRepos: clonedRepositories,
+                issueTitle: issue.title ?? 'Untitled issue',
+                issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
+                ghToken: issueInstallationAuth.token,
+                retry: true,
+                phaseName: 'issue-fix-retry.fix-attempt',
+                assigneeReview: {
+                    assignees: (issue.assignees ?? []).map((assignee) => assignee.login),
+                    membershipOctokit: readOctokit,
+                },
+            });
+            metricRepository = fixResult.repository;
+            metricOutcome = fixResult.attempted && fixResult.prCreated ? 'success' : 'failure';
+            const reason = 'reason' in fixResult ? fixResult.reason : undefined;
+            const isDryRun = 'dryRun' in fixResult && fixResult.dryRun === true;
+            recordDecision('issue-fix-retry.outcome', {
+                attempted: fixResult.attempted,
+                pr_created: fixResult.attempted && fixResult.prCreated,
+                reason,
+                pr_url: 'prUrl' in fixResult ? fixResult.prUrl : undefined,
+            });
+            // No PR is a failed retry — unless it was a dry run (expected).
+            if (!fixResult.attempted || !fixResult.prCreated) {
+                if (!isDryRun) {
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: reason ?? 'Fix retry produced no PR',
+                    });
+                }
+                if (!ctx.dryRun) {
+                    await postAutoFixFailureComment({
+                        octokit: writeOctokit,
+                        ctx,
+                        reason: reason ?? 'Unknown reason',
+                        targetRepoFullName: fixResult.repository,
+                        ...('prNumber' in fixResult ? { prNumber: fixResult.prNumber } : {}),
+                        ...('interruption' in fixResult
+                            ? { interruption: fixResult.interruption }
+                            : {}),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Fix retry task failed', {
+                task: 'issue-fix-retry',
+                issueNumber: ctx.issueNumber,
+                error: message,
+                durationMs: performance.now() - startedAt,
+            });
+            // The catch swallows the error (posts a user message), so set the
+            // span status explicitly — withPhase only auto-marks ERROR on rethrow.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            try {
+                await postComment('Sorry, the fix retry encountered an error. Please try again or contact the team maintaining the bot.');
+            }
+            catch (commentError) {
+                logger.warn('Failed to post fix retry failure response', {
+                    task: 'issue-fix-retry',
+                    issueNumber: ctx.issueNumber,
+                    error: commentError instanceof Error
+                        ? commentError.message
+                        : String(commentError),
+                });
+            }
+            exitCode = 1;
+        }
+        finally {
+            await removeIssueCommentReactionIfPresent({
+                octokit: writeOctokit,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId: ctx.reactionId,
+                warnMessage: 'Failed to remove fix retry reaction',
+                successMessage: 'Fix retry reaction removed',
+                logMeta: {
+                    task: 'issue-fix-retry',
+                    reactionId: ctx.reactionId,
+                },
+            });
+            await recordTaskMetrics({
+                type: 'fix',
+                repository: metricRepository,
+                model: 'openai',
+                outcome: metricOutcome,
+                durationMs: performance.now() - startedAt,
+                sandboxVariant: ctx.sandboxVariant,
+            });
+        }
+    });
+    if (exitCode !== 0) {
+        await shutdownTracing();
+        process.exit(exitCode);
+    }
+}
+if (process.env.VITEST !== 'true') {
+    main();
+}

package/sandbox/dist/tasks/issue-summarize/context.js

@@ -0,0 +1,21 @@
+import { optionalPositiveInt, requiredEnv, requiredPositiveInt } from '../../core/environment.js';
+export function parseSummarizeContext(env = process.env) {
+    const commentId = optionalPositiveInt(env.COMMENT_ID);
+    const reactionId = optionalPositiveInt(env.REACTION_ID);
+    const dryRun = env.DRY_RUN?.toLowerCase() === 'true';
+    return {
+        owner: requiredEnv('REPO_OWNER', env),
+        repo: requiredEnv('REPO_NAME', env),
+        issueNumber: requiredPositiveInt('ISSUE_NUMBER', env),
+        installationId: requiredPositiveInt('INSTALLATION_ID', env),
+        appId: requiredEnv('APP_ID', env),
+        privateKey: requiredEnv('PRIVATE_KEY', env),
+        githubToken: requiredEnv('GITHUB_TOKEN', env),
+        geminiApiKey: requiredEnv('GEMINI_API_KEY', env),
+        openRouterApiKey: requiredEnv('OPENROUTER_API_KEY', env),
+        commentId,
+        reactionId,
+        deliveryId: env.DELIVERY_ID,
+        dryRun,
+    };
+}

package/sandbox/dist/tasks/issue-summarize/media.js

@@ -0,0 +1,335 @@
+import { logger } from '../../core/logging.js';
+const MAX_MEDIA_REFERENCES = 25;
+const MAX_MEDIA_IMAGES_FOR_PROMPT = 8;
+const MAX_MEDIA_IMAGE_BYTES = 2_000_000;
+const MAX_MEDIA_TOTAL_BYTES = 8_000_000;
+const MAX_MEDIA_SOURCE_CONTEXT_CHARS = 12_000;
+const IMAGE_EXTENSION_REGEX = /\.(png|jpe?g|webp|bmp|svg|heic|heif)(\?.*)?$/i;
+const UNSUPPORTED_MEDIA_EXTENSION_REGEX = /\.(gif|mp4|mov|avi|webm|mkv|m4v)(\?.*)?$/i;
+const HTML_IMAGE_REGEX = /<img[^>]*\bsrc=["'](https?:\/\/[^"'\s>]+)["'][^>]*>/gi;
+const MARKDOWN_IMAGE_REGEX = /!\[[^\]]*]\((https?:\/\/[^)\s]+)\)/gi;
+const MARKDOWN_LINK_REGEX = /\[[^\]]*]\((https?:\/\/[^)\s]+)\)/gi;
+const BARE_URL_REGEX = /https?:\/\/[^\s<>()"']+/gi;
+function extractUrlMatches(text) {
+    const matches = [];
+    for (const match of text.matchAll(HTML_IMAGE_REGEX)) {
+        const url = match[1];
+        const index = match.index ?? 0;
+        if (url) {
+            matches.push({ url, index, explicitMedia: true });
+        }
+    }
+    for (const match of text.matchAll(MARKDOWN_IMAGE_REGEX)) {
+        const url = match[1];
+        const index = match.index ?? 0;
+        if (url) {
+            matches.push({ url, index, explicitMedia: true });
+        }
+    }
+    for (const match of text.matchAll(MARKDOWN_LINK_REGEX)) {
+        const url = match[1];
+        const index = match.index ?? 0;
+        if (url) {
+            matches.push({ url, index, explicitMedia: false });
+        }
+    }
+    for (const match of text.matchAll(BARE_URL_REGEX)) {
+        const url = match[0];
+        const index = match.index ?? 0;
+        if (url) {
+            matches.push({ url, index, explicitMedia: false });
+        }
+    }
+    return matches;
+}
+function normalizeUrl(rawUrl) {
+    return rawUrl.replace(/[)\],.;!?"'>]+$/, '');
+}
+function isMediaCandidate(url, explicitMedia) {
+    if (UNSUPPORTED_MEDIA_EXTENSION_REGEX.test(url)) {
+        return false;
+    }
+    if (IMAGE_EXTENSION_REGEX.test(url)) {
+        return true;
+    }
+    try {
+        const parsed = new URL(url);
+        if (parsed.pathname.includes('/user-attachments/')) {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return explicitMedia;
+}
+function snippetAround(text, index, radius = 180) {
+    const start = Math.max(0, index - radius);
+    const end = Math.min(text.length, index + radius);
+    return text.slice(start, end).replace(/\s+/g, ' ').trim();
+}
+export function extractMediaReferences(entries, maxReferences = MAX_MEDIA_REFERENCES) {
+    const references = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        const sourceTexts = [entry.body, entry.bodyHtml ?? ''];
+        for (const sourceText of sourceTexts) {
+            if (!sourceText) {
+                continue;
+            }
+            const matches = extractUrlMatches(sourceText);
+            for (const match of matches) {
+                const url = normalizeUrl(match.url);
+                if (!isMediaCandidate(url, match.explicitMedia)) {
+                    continue;
+                }
+                const dedupeKey = `${entry.source}:${entry.id}:${url}`;
+                if (seen.has(dedupeKey)) {
+                    continue;
+                }
+                seen.add(dedupeKey);
+                references.push({
+                    url,
+                    source: entry.source,
+                    sourceId: entry.id,
+                    sourceLabel: entry.source === 'issue_body'
+                        ? `Issue description (issue #${entry.id})`
+                        : `Comment #${entry.id}`,
+                    author: entry.author,
+                    sourceBody: entry.body,
+                    contextSnippet: snippetAround(sourceText, match.index),
+                });
+                if (references.length >= maxReferences) {
+                    return references;
+                }
+            }
+        }
+    }
+    return references;
+}
+function buildMediaRequestHeaders({ includeRange }) {
+    const headers = new Headers({
+        Accept: 'image/*;q=0.9,*/*;q=0.8',
+        'User-Agent': 'doistbot-media-fetch/1.0',
+    });
+    if (includeRange) {
+        headers.set('Range', 'bytes=0-1023');
+    }
+    return headers;
+}
+function isImageContentType(contentType) {
+    if (!contentType) {
+        return false;
+    }
+    const mimeType = contentType.toLowerCase().split(';', 1)[0]?.trim() ?? '';
+    return mimeType.startsWith('image/') && mimeType !== 'image/gif';
+}
+export async function inspectMediaReferences(references, fetcherOrOptions = fetch) {
+    const { fetcher } = typeof fetcherOrOptions === 'function'
+        ? { fetcher: fetcherOrOptions }
+        : {
+            fetcher: fetcherOrOptions.fetcher ?? fetch,
+        };
+    const inspections = [];
+    for (const reference of references) {
+        try {
+            let response = await fetcher(reference.url, {
+                method: 'HEAD',
+                redirect: 'follow',
+                headers: buildMediaRequestHeaders({
+                    includeRange: false,
+                }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            const headContentType = response.headers.get('content-type')?.toLowerCase();
+            const shouldRetryWithGet = !response.ok || !headContentType || headContentType.startsWith('text/html');
+            if (shouldRetryWithGet) {
+                response = await fetcher(reference.url, {
+                    method: 'GET',
+                    redirect: 'follow',
+                    headers: buildMediaRequestHeaders({
+                        includeRange: true,
+                    }),
+                    signal: AbortSignal.timeout(10_000),
+                });
+            }
+            if (!response.ok) {
+                inspections.push({
+                    url: reference.url,
+                    sourceLabel: reference.sourceLabel,
+                    author: reference.author,
+                    contextSnippet: reference.contextSnippet,
+                    status: 'fetch_failed',
+                    note: `Failed to fetch media (${response.status} ${response.statusText}).`,
+                });
+                continue;
+            }
+            const contentType = response.headers.get('content-type') ?? 'unknown';
+            const rawContentLength = response.headers.get('content-length');
+            const contentLength = rawContentLength ? Number(rawContentLength) : undefined;
+            const isMedia = isImageContentType(contentType);
+            if (!isMedia) {
+                inspections.push({
+                    url: reference.url,
+                    sourceLabel: reference.sourceLabel,
+                    author: reference.author,
+                    contextSnippet: reference.contextSnippet,
+                    status: 'not_media',
+                    note: `Fetched URL but content type is "${contentType}".`,
+                    contentType,
+                    contentLength: Number.isFinite(contentLength) ? contentLength : undefined,
+                });
+                continue;
+            }
+            inspections.push({
+                url: reference.url,
+                sourceLabel: reference.sourceLabel,
+                author: reference.author,
+                contextSnippet: reference.contextSnippet,
+                status: 'fetched',
+                note: 'Fetched media metadata successfully.',
+                contentType,
+                contentLength: Number.isFinite(contentLength) ? contentLength : undefined,
+            });
+        }
+        catch (error) {
+            inspections.push({
+                url: reference.url,
+                sourceLabel: reference.sourceLabel,
+                author: reference.author,
+                contextSnippet: reference.contextSnippet,
+                status: 'fetch_failed',
+                note: `Media fetch failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+    }
+    return inspections;
+}
+function truncateForMediaSourceContext(body) {
+    if (body.length <= MAX_MEDIA_SOURCE_CONTEXT_CHARS) {
+        return body;
+    }
+    return `${body.slice(0, MAX_MEDIA_SOURCE_CONTEXT_CHARS)}\n\n[...truncated media source context due size limit...]`;
+}
+function mediaReferenceKey(reference) {
+    return `${reference.url}::${reference.sourceLabel}`;
+}
+function buildMediaSourceContext(reference) {
+    const sourceType = reference.source === 'issue_body'
+        ? 'Issue description'
+        : `Comment ${reference.sourceLabel.replace('Comment #', '#')}`;
+    return [
+        `Source type: ${sourceType}`,
+        `Source author: ${reference.author}`,
+        '',
+        'Source text:',
+        truncateForMediaSourceContext(reference.sourceBody),
+    ].join('\n');
+}
+export async function buildMediaPromptImages(references, inspections, options = {}) {
+    const fetcher = options.fetcher ?? fetch;
+    const maxImages = options.maxImages ?? MAX_MEDIA_IMAGES_FOR_PROMPT;
+    const inspectionMap = new Map(inspections.map((inspection) => [mediaReferenceKey(inspection), inspection]));
+    const images = [];
+    let totalBytes = 0;
+    for (const reference of references) {
+        if (images.length >= maxImages) {
+            break;
+        }
+        const inspection = inspectionMap.get(mediaReferenceKey(reference));
+        if (inspection?.status !== 'fetched') {
+            continue;
+        }
+        const inspectionContentType = inspection.contentType?.toLowerCase();
+        if (!inspectionContentType || !isImageContentType(inspectionContentType)) {
+            continue;
+        }
+        try {
+            const response = await fetcher(reference.url, {
+                method: 'GET',
+                redirect: 'follow',
+                headers: buildMediaRequestHeaders({
+                    includeRange: false,
+                }),
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!response.ok) {
+                logger.warn('Failed to fetch full image bytes for summarize multimodal context', {
+                    url: reference.url,
+                    status: response.status,
+                    statusText: response.statusText,
+                });
+                continue;
+            }
+            const contentType = response.headers.get('content-type') ?? inspection.contentType ?? '';
+            if (!isImageContentType(contentType)) {
+                continue;
+            }
+            const declaredLength = Number(response.headers.get('content-length') ?? '');
+            if (Number.isFinite(declaredLength) && declaredLength > MAX_MEDIA_IMAGE_BYTES) {
+                logger.warn('Skipping image that exceeds per-image size budget', {
+                    url: reference.url,
+                    declaredLength,
+                    limit: MAX_MEDIA_IMAGE_BYTES,
+                });
+                continue;
+            }
+            const bytes = Buffer.from(await response.arrayBuffer());
+            if (bytes.length > MAX_MEDIA_IMAGE_BYTES) {
+                logger.warn('Skipping image that exceeds per-image size budget after download', {
+                    url: reference.url,
+                    bytes: bytes.length,
+                    limit: MAX_MEDIA_IMAGE_BYTES,
+                });
+                continue;
+            }
+            if (totalBytes + bytes.length > MAX_MEDIA_TOTAL_BYTES) {
+                logger.warn('Stopping multimodal image collection due total size budget', {
+                    nextUrl: reference.url,
+                    currentTotalBytes: totalBytes,
+                    nextBytes: bytes.length,
+                    limit: MAX_MEDIA_TOTAL_BYTES,
+                });
+                break;
+            }
+            totalBytes += bytes.length;
+            images.push({
+                url: reference.url,
+                sourceLabel: reference.sourceLabel,
+                author: reference.author,
+                sourceContext: buildMediaSourceContext(reference),
+                contentType,
+                dataBase64: bytes.toString('base64'),
+            });
+        }
+        catch (error) {
+            logger.warn('Failed to collect image bytes for summarize multimodal context', {
+                url: reference.url,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return images;
+}
+export function formatMediaContext(mediaInspections) {
+    if (mediaInspections.length === 0) {
+        return 'No candidate screenshot/video links were detected in the issue description or comments.';
+    }
+    return mediaInspections
+        .map((inspection, index) => {
+        const contentType = inspection.contentType
+            ? `, content-type: ${inspection.contentType}`
+            : '';
+        const contentLength = inspection.contentLength != null
+            ? `, content-length: ${inspection.contentLength}`
+            : '';
+        return [
+            `${index + 1}. URL: ${inspection.url}`,
+            `   Source: ${inspection.sourceLabel} (author: ${inspection.author})`,
+            `   Fetch status: ${inspection.status}${contentType}${contentLength}`,
+            `   Note: ${inspection.note}`,
+            `   Context snippet: ${inspection.contextSnippet || '(none)'}`,
+        ].join('\n');
+    })
+        .join('\n\n');
+}