@qearlyao/familiar 0.1.0

package/dist/generated-media.js

@@ -0,0 +1,86 @@
+import { lstat, mkdir, readdir, rm } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+export function createGeneratedMediaSink() {
+    const attachments = [];
+    return {
+        add(attachment) {
+            attachments.push(attachment);
+        },
+        drain() {
+            return attachments.splice(0);
+        },
+    };
+}
+export function generatedAttachmentsDir(config) {
+    return resolve(config.workspace.dataDir, "attachments", "generated");
+}
+export function attachmentsDir(config) {
+    return resolve(config.workspace.dataDir, "attachments");
+}
+export function browserScreenshotsDir(config) {
+    return resolve(config.workspace.dataDir, "attachments", "screenshot");
+}
+export async function ensureGeneratedAttachmentsDir(config) {
+    const dir = generatedAttachmentsDir(config);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function ensureBrowserScreenshotsDir(config) {
+    const dir = browserScreenshotsDir(config);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function cleanupGeneratedAttachments(config, now = Date.now()) {
+    const retentionDays = config.media.generatedRetentionDays;
+    if (retentionDays <= 0)
+        return 0;
+    const dir = generatedAttachmentsDir(config);
+    const cutoff = now - retentionDays * 24 * 60 * 60 * 1000;
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+            return 0;
+        throw error;
+    }
+    let removed = 0;
+    for (const entry of entries) {
+        const path = join(dir, entry);
+        const fileStat = await lstat(path).catch(() => undefined);
+        if (!fileStat?.isFile() || fileStat.mtimeMs > cutoff)
+            continue;
+        await rm(path).catch((error) => {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
+                throw error;
+        });
+        removed++;
+    }
+    return removed;
+}
+export function publicAttachmentPath(config, localPath) {
+    const absolutePath = resolve(localPath);
+    const generatedRelativePath = relative(generatedAttachmentsDir(config), absolutePath);
+    if (generatedRelativePath && !generatedRelativePath.startsWith("..") && !isAbsolute(generatedRelativePath)) {
+        return `/api/web/attachments/${generatedRelativePath
+            .split(/[\\/]+/)
+            .map(encodeURIComponent)
+            .join("/")}`;
+    }
+    const screenshotRelativePath = relative(browserScreenshotsDir(config), absolutePath);
+    if (screenshotRelativePath && !screenshotRelativePath.startsWith("..") && !isAbsolute(screenshotRelativePath)) {
+        return `/api/web/attachments/screenshot/${screenshotRelativePath
+            .split(/[\\/]+/)
+            .map(encodeURIComponent)
+            .join("/")}`;
+    }
+    const relativePath = relative(attachmentsDir(config), absolutePath);
+    if (relativePath.startsWith("..") || isAbsolute(relativePath) || relativePath === "") {
+        throw new Error(`Attachment path is outside generated attachments dir: ${localPath}`);
+    }
+    return `/api/web/attachments/${relativePath
+        .split(/[\\/]+/)
+        .map(encodeURIComponent)
+        .join("/")}`;
+}

package/dist/image-derivatives.js

@@ -0,0 +1,102 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, resolve } from "node:path";
+import sharp from "sharp";
+import { attachmentsDir } from "./generated-media.js";
+export const MAX_INLINE_IMAGE_BASE64_BYTES = 4.5 * 1024 * 1024;
+const DERIVED_IMAGE_MIME_TYPE = "image/webp";
+const DERIVED_IMAGE_EXTENSION = ".webp";
+const DERIVED_IMAGE_MAX_EDGE = 1600;
+const DERIVED_IMAGE_QUALITY_STEPS = [82, 72, 62, 52];
+const DERIVED_IMAGE_EDGE_STEPS = [1600, 1400, 1200, 1000, 800, 640];
+function safeDerivedStem(name) {
+    const base = basename(name, extname(name))
+        .replace(/[^A-Za-z0-9._=-]+/g, "_")
+        .slice(0, 96);
+    return base || "image";
+}
+function derivedImagePath(config, source, fingerprint) {
+    return resolve(attachmentsDir(config), "derived", "image", `${safeDerivedStem(source.name)}-${fingerprint}${DERIVED_IMAGE_EXTENSION}`);
+}
+async function sourceFingerprint(source, localPath) {
+    if (source.sha256)
+        return source.sha256.slice(0, 16);
+    const buffer = await readFile(localPath);
+    return createHash("sha256").update(buffer).digest("hex").slice(0, 16);
+}
+function inlineBase64Size(bytes) {
+    return Math.ceil(bytes / 3) * 4;
+}
+async function outputWithinInlineLimit(path) {
+    const fileStat = await stat(path).catch(() => undefined);
+    return !!fileStat && inlineBase64Size(fileStat.size) <= MAX_INLINE_IMAGE_BASE64_BYTES;
+}
+function derivativeNote(width, height) {
+    const dimensions = width && height ? ` ${width}x${height}` : "";
+    return `[Resized image${dimensions} for inline model input.]`;
+}
+export async function ensureInlineImageDerivative(config, source) {
+    const localPath = source.localPath;
+    if (!localPath)
+        return undefined;
+    if (!source.mimeType?.startsWith("image/"))
+        return undefined;
+    if (source.derived?.image?.localPath && (await outputWithinInlineLimit(source.derived.image.localPath))) {
+        return source.derived.image;
+    }
+    const sourceStat = await stat(localPath).catch(() => undefined);
+    const sourceSize = source.size ?? sourceStat?.size;
+    if (sourceSize !== undefined && inlineBase64Size(sourceSize) <= MAX_INLINE_IMAGE_BASE64_BYTES)
+        return undefined;
+    const fingerprint = await sourceFingerprint(source, localPath);
+    const outputPath = derivedImagePath(config, source, fingerprint);
+    if (await outputWithinInlineLimit(outputPath)) {
+        const metadata = await sharp(outputPath).metadata();
+        return {
+            localPath: outputPath,
+            mimeType: DERIVED_IMAGE_MIME_TYPE,
+            size: (await stat(outputPath)).size,
+            width: metadata.width,
+            height: metadata.height,
+            note: derivativeNote(metadata.width, metadata.height),
+        };
+    }
+    const original = sharp(localPath, { animated: false, limitInputPixels: 64_000_000 }).rotate();
+    let best;
+    for (const edge of DERIVED_IMAGE_EDGE_STEPS) {
+        if (edge > DERIVED_IMAGE_MAX_EDGE)
+            continue;
+        for (const quality of DERIVED_IMAGE_QUALITY_STEPS) {
+            const output = await original
+                .clone()
+                .resize({ width: edge, height: edge, fit: "inside", withoutEnlargement: true })
+                .webp({ quality })
+                .toBuffer({ resolveWithObject: true });
+            best = { buffer: output.data, width: output.info.width, height: output.info.height };
+            if (inlineBase64Size(output.data.length) <= MAX_INLINE_IMAGE_BASE64_BYTES) {
+                await mkdir(dirname(outputPath), { recursive: true });
+                await writeFile(outputPath, output.data);
+                return {
+                    localPath: outputPath,
+                    mimeType: DERIVED_IMAGE_MIME_TYPE,
+                    size: output.data.length,
+                    width: output.info.width,
+                    height: output.info.height,
+                    note: derivativeNote(output.info.width, output.info.height),
+                };
+            }
+        }
+    }
+    if (!best)
+        return undefined;
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, best.buffer);
+    return {
+        localPath: outputPath,
+        mimeType: DERIVED_IMAGE_MIME_TYPE,
+        size: best.buffer.length,
+        width: best.width,
+        height: best.height,
+        note: derivativeNote(best.width, best.height),
+    };
+}

package/dist/image-gen.js

@@ -0,0 +1,440 @@
+import { randomUUID } from "node:crypto";
+import { lstat, writeFile } from "node:fs/promises";
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+import { findEnvKeys, generateImages, getEnvApiKey, getImageModels, getImageProviders, } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import { ensureGeneratedAttachmentsDir } from "./generated-media.js";
+import { ensureInlineImageDerivative } from "./image-derivatives.js";
+import { promptImagesFromAttachments } from "./inbound-attachments.js";
+import { parseModelRef } from "./models.js";
+const IMAGE_GEN_NOTICE_PREFIX = "Generated image attachment:";
+const OPENROUTER_IMAGE_BASE_URL = "https://openrouter.ai/api/v1";
+const IMAGE_MIME_BY_EXTENSION = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+const imageGenSchema = Type.Object({
+    prompt: Type.String({ description: "Image generation prompt." }),
+    referenceImages: Type.Optional(Type.Array(Type.String(), {
+        description: "Optional. Image attachment IDs or names, or workspace-relative image file paths, to use as visual references. Prefer IDs from the attachment tags when available.",
+    })),
+}, { additionalProperties: false });
+function formatImageGenNotice(name) {
+    return `${IMAGE_GEN_NOTICE_PREFIX} ${name}`;
+}
+export function imageExtension(mimeType) {
+    const normalized = mimeType.toLowerCase();
+    if (normalized === "image/jpeg" || normalized === "image/jpg")
+        return "jpg";
+    if (normalized === "image/webp")
+        return "webp";
+    if (normalized === "image/gif")
+        return "gif";
+    if (normalized === "image/svg+xml")
+        return "svg";
+    return "png";
+}
+function resolveConfiguredBaseUrl(config, ref, model) {
+    return (config.models.baseUrls[ref.key] ??
+        config.models.baseUrls[ref.provider] ??
+        model?.baseUrl ??
+        (ref.provider === "openrouter" ? OPENROUTER_IMAGE_BASE_URL : undefined));
+}
+function resolveConfiguredApiKeyEnv(config, model) {
+    return config.models.apiKeyEnvs[`${model.provider}/${model.id}`] ?? config.models.apiKeyEnvs[model.provider];
+}
+function findBuiltInImageModel(ref) {
+    if (!getImageProviders().includes(ref.provider))
+        return undefined;
+    return getImageModels(ref.provider).find((model) => model.id === ref.id);
+}
+export function resolveImageModel(config, ref) {
+    const builtIn = findBuiltInImageModel(ref);
+    const baseUrl = resolveConfiguredBaseUrl(config, ref, builtIn);
+    if (!baseUrl) {
+        throw new Error(`Missing image model base URL for ${ref.key}. Set models.base_urls.${ref.provider}.`);
+    }
+    const model = builtIn
+        ? { ...builtIn, api: config.imageGen.api, baseUrl }
+        : {
+            id: ref.id,
+            name: ref.id,
+            api: config.imageGen.api,
+            provider: ref.provider,
+            baseUrl,
+            input: ["text", "image"],
+            output: ["image", "text"],
+            cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+        };
+    return model;
+}
+function resolveImageModelApiKey(config, model) {
+    const configuredEnv = resolveConfiguredApiKeyEnv(config, model);
+    if (configuredEnv) {
+        const apiKey = process.env[configuredEnv];
+        if (!apiKey)
+            throw new Error(`Missing image generation API key env: ${configuredEnv}`);
+        return apiKey;
+    }
+    const apiKey = getEnvApiKey(model.provider);
+    if (apiKey)
+        return apiKey;
+    const envKeys = findEnvKeys(model.provider);
+    const hint = envKeys?.length ? envKeys.join(", ") : `models.api_key_envs.${model.provider}`;
+    throw new Error(`Missing image generation API key for ${model.provider}/${model.id}: ${hint}`);
+}
+function imageResultError(result) {
+    if (result.stopReason === "error")
+        return result.errorMessage ?? "image generation failed";
+    if (result.stopReason === "aborted")
+        return result.errorMessage ?? "image generation aborted";
+    if (!result.output.some((item) => item.type === "image"))
+        return "image generation returned no image output";
+    return undefined;
+}
+function textOutput(result) {
+    return result.output
+        .filter((item) => item.type === "text")
+        .map((item) => item.text.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function imageMimeTypeFromBytes(buffer) {
+    if (buffer.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
+        return "image/jpeg";
+    if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return "image/png";
+    }
+    if (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
+        return "image/gif";
+    }
+    if (buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    return undefined;
+}
+function recoveredImageFromBase64(value) {
+    const data = value.trim();
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(data) || data.length % 4 !== 0)
+        return undefined;
+    const buffer = Buffer.from(data, "base64");
+    if (!buffer.length)
+        return undefined;
+    const detectedMimeType = imageMimeTypeFromBytes(buffer);
+    if (!detectedMimeType)
+        return undefined;
+    return {
+        mimeType: detectedMimeType,
+        data,
+    };
+}
+function recoveredImageFromText(text) {
+    const trimmed = text.trim();
+    const dataUrlMatch = trimmed.match(/^data:(image\/[^;]+);base64,([A-Za-z0-9+/]+={0,2})$/);
+    if (dataUrlMatch)
+        return recoveredImageFromBase64(dataUrlMatch[2] ?? "");
+    const embeddedDataUrlMatch = text.match(/data:(image\/[^;)\]\s]+);base64,([A-Za-z0-9+/]+={0,2})/);
+    if (embeddedDataUrlMatch) {
+        return recoveredImageFromBase64(embeddedDataUrlMatch[2] ?? "");
+    }
+    return recoveredImageFromBase64(trimmed);
+}
+function normalizeCompatibleImageText(result) {
+    if (result.output.some((item) => item.type === "image"))
+        return result;
+    const output = [];
+    for (const item of result.output) {
+        if (item.type !== "text") {
+            output.push(item);
+            continue;
+        }
+        const recovered = recoveredImageFromText(item.text);
+        if (!recovered) {
+            output.push(item);
+            continue;
+        }
+        output.push({ type: "image", mimeType: recovered.mimeType, data: recovered.data });
+    }
+    if (!output.some((item) => item.type === "image"))
+        return result;
+    return { ...result, output };
+}
+function mimeTypeFromPath(path) {
+    return IMAGE_MIME_BY_EXTENSION[extname(path).toLowerCase()];
+}
+function resolveWorkspaceReferencePath(config, rawRef) {
+    const path = isAbsolute(rawRef) ? resolve(rawRef) : resolve(config.workspacePath, rawRef);
+    const workspaceRelative = relative(config.workspacePath, path);
+    if (!workspaceRelative || workspaceRelative.startsWith("..") || isAbsolute(workspaceRelative)) {
+        throw new Error(`Reference image path must be inside the workspace: ${rawRef}`);
+    }
+    return path;
+}
+async function collectWorkspaceReferenceImages(config, rawRef) {
+    const path = resolveWorkspaceReferencePath(config, rawRef);
+    const pathStat = await lstat(path).catch(() => undefined);
+    if (!pathStat)
+        throw new Error(`Reference image path not found: ${rawRef}`);
+    if (pathStat.isSymbolicLink())
+        throw new Error(`Reference image path cannot be a symlink: ${rawRef}`);
+    if (pathStat.isDirectory()) {
+        throw new Error(`Reference image path must be a file, not a folder: ${rawRef}`);
+    }
+    if (!pathStat.isFile())
+        throw new Error(`Reference image path is not a file or folder: ${rawRef}`);
+    const mimeType = mimeTypeFromPath(path);
+    if (!mimeType)
+        throw new Error(`Reference image path is not a supported image: ${rawRef}`);
+    return [
+        {
+            localPath: path,
+            name: basename(path),
+            mimeType,
+            size: pathStat.size,
+        },
+    ];
+}
+function splitReferenceImages(attachments, references) {
+    if (!references?.length)
+        return { attachments: [], workspaceRefs: [] };
+    const imageAttachments = attachments.filter((attachment) => {
+        return (attachment.localPath &&
+            attachment.mimeType?.startsWith("image/") &&
+            (!attachment.kind || attachment.kind === "image"));
+    });
+    const selected = [];
+    const workspaceRefs = [];
+    const seenAttachments = new Set();
+    const seenWorkspaceRefs = new Set();
+    for (const rawRef of references) {
+        const ref = rawRef.trim();
+        if (!ref)
+            continue;
+        const attachment = imageAttachments.find((candidate) => candidate.id === ref || candidate.name === ref);
+        if (attachment) {
+            if (seenAttachments.has(attachment.id))
+                continue;
+            seenAttachments.add(attachment.id);
+            selected.push(attachment);
+            continue;
+        }
+        const anyAttachment = attachments.find((candidate) => candidate.id === ref || candidate.name === ref);
+        if (anyAttachment) {
+            throw new Error(`Reference image is not an image attachment: ${ref}`);
+        }
+        if (seenWorkspaceRefs.has(ref))
+            continue;
+        seenWorkspaceRefs.add(ref);
+        workspaceRefs.push(ref);
+    }
+    return { attachments: selected, workspaceRefs };
+}
+async function workspaceReferenceAttachments(config, images) {
+    const attachments = [];
+    for (const image of images) {
+        const attachment = {
+            id: `workspace:${image.localPath}`,
+            name: image.name,
+            kind: "image",
+            mimeType: image.mimeType,
+            size: image.size,
+            localPath: image.localPath,
+        };
+        const derivedImage = await ensureInlineImageDerivative(config, attachment);
+        if (derivedImage) {
+            attachment.derived = {
+                ...attachment.derived,
+                image: derivedImage,
+            };
+        }
+        attachments.push(attachment);
+    }
+    return attachments;
+}
+async function buildImageContext(model, prompt, references, workspaceRefs, config) {
+    const input = [{ type: "text", text: prompt }];
+    const hasReferences = references.length > 0 || workspaceRefs.some((ref) => ref.trim().length > 0);
+    if (!hasReferences)
+        return { input };
+    if (!model.input.includes("image")) {
+        throw new Error(`Image model does not support reference images: ${model.provider}/${model.id}`);
+    }
+    const workspaceImages = [];
+    const seenWorkspaceImagePaths = new Set();
+    for (const rawRef of workspaceRefs) {
+        if (!rawRef.trim())
+            continue;
+        for (const image of await collectWorkspaceReferenceImages(config, rawRef)) {
+            if (seenWorkspaceImagePaths.has(image.localPath))
+                continue;
+            seenWorkspaceImagePaths.add(image.localPath);
+            workspaceImages.push(image);
+        }
+    }
+    const promptImages = await promptImagesFromAttachments([
+        ...references,
+        ...(await workspaceReferenceAttachments(config, workspaceImages)),
+    ]);
+    if (promptImages.promptSuffix)
+        input.push({ type: "text", text: promptImages.promptSuffix });
+    input.push(...promptImages.images);
+    if (!promptImages.images.length)
+        throw new Error("No reference images could be inlined for image_gen.");
+    return { input };
+}
+async function writeGeneratedImages(config, mediaSink, result) {
+    const attachmentDir = await ensureGeneratedAttachmentsDir(config);
+    const attachments = [];
+    for (const item of result.output) {
+        if (item.type !== "image")
+            continue;
+        const buffer = Buffer.from(item.data, "base64");
+        const extension = imageExtension(item.mimeType);
+        const id = `image_gen_${randomUUID()}`;
+        const name = `${id}.${extension}`;
+        const localPath = resolve(attachmentDir, name);
+        await writeFile(localPath, buffer);
+        const attachment = {
+            id,
+            name,
+            kind: "image",
+            source: "generated",
+            mimeType: item.mimeType,
+            size: buffer.length,
+            localPath,
+            provider: result.provider,
+            toolName: "image_gen",
+        };
+        mediaSink.add(attachment);
+        attachments.push({
+            id,
+            name,
+            localPath,
+            mimeType: item.mimeType,
+            size: buffer.length,
+        });
+    }
+    return attachments;
+}
+async function tryGenerateImages(config, ref, prompt, references, workspaceRefs, signal, generate) {
+    const model = resolveImageModel(config, ref);
+    const context = await buildImageContext(model, prompt, references, workspaceRefs, config);
+    return {
+        model,
+        result: normalizeCompatibleImageText(await generate(model, context, {
+            apiKey: resolveImageModelApiKey(config, model),
+            signal,
+            timeoutMs: config.imageGen.timeoutMs,
+        })),
+    };
+}
+function attemptDetails(model, result) {
+    return {
+        provider: model.provider,
+        model: model.id,
+        api: model.api,
+        baseUrl: model.baseUrl,
+        ...(result.responseId ? { responseId: result.responseId } : {}),
+        stopReason: result.stopReason,
+        ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+    };
+}
+export function createImageGenTool(config, mediaSink, deps = {}) {
+    return {
+        name: "image_gen",
+        label: "Image Gen",
+        description: "make an image from a prompt. pass referenceImages to riff on existing pictures.",
+        parameters: imageGenSchema,
+        executionMode: "sequential",
+        async execute(_toolCallId, input, signal) {
+            const prompt = input.prompt.trim();
+            if (!prompt)
+                throw new Error("image_gen prompt is required.");
+            const primaryRef = parseModelRef(config.imageGen.model);
+            if (!primaryRef)
+                throw new Error(`Invalid image_gen.model: ${config.imageGen.model}`);
+            const fallbackRef = config.imageGen.fallbackModel ? parseModelRef(config.imageGen.fallbackModel) : undefined;
+            if (config.imageGen.fallbackModel && !fallbackRef) {
+                throw new Error(`Invalid image_gen.fallback_model: ${config.imageGen.fallbackModel}`);
+            }
+            const allAttachmentRefs = deps.referenceAttachments?.() ?? [];
+            const { attachments: attachmentReferences, workspaceRefs: workspaceReferences } = splitReferenceImages(allAttachmentRefs, input.referenceImages);
+            const generate = deps.generateImages ?? generateImages;
+            const attempts = [];
+            let selected;
+            let selectedError = "";
+            for (const ref of [primaryRef, fallbackRef].filter((ref) => !!ref)) {
+                let attempt;
+                try {
+                    attempt = await tryGenerateImages(config, ref, prompt, attachmentReferences, workspaceReferences, signal, generate);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    let baseUrl = "";
+                    try {
+                        baseUrl = resolveImageModel(config, ref).baseUrl;
+                    }
+                    catch {
+                        baseUrl = "";
+                    }
+                    attempts.push({
+                        provider: ref.provider,
+                        model: ref.id,
+                        api: config.imageGen.api,
+                        baseUrl,
+                        stopReason: "error",
+                        errorMessage: message,
+                    });
+                    if (message.includes("does not support reference images") && ref === primaryRef && fallbackRef) {
+                        selectedError = message;
+                        continue;
+                    }
+                    throw error;
+                }
+                if (!attempt)
+                    continue;
+                attempts.push(attemptDetails(attempt.model, attempt.result));
+                const error = imageResultError(attempt.result);
+                if (!error) {
+                    selected = attempt;
+                    break;
+                }
+                selectedError = error;
+                if (attempt.result.stopReason === "aborted")
+                    break;
+            }
+            if (!selected)
+                throw new Error(`Image generation failed: ${selectedError}`);
+            const attachments = await writeGeneratedImages(config, mediaSink, selected.result);
+            const notices = attachments.map((attachment) => formatImageGenNotice(attachment.name));
+            const sideText = textOutput(selected.result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [sideText, ...notices].filter(Boolean).join("\n"),
+                    },
+                ],
+                details: {
+                    provider: selected.model.provider,
+                    model: selected.model.id,
+                    api: selected.model.api,
+                    baseUrl: selected.model.baseUrl,
+                    prompt,
+                    ...(selected.result.responseId ? { responseId: selected.result.responseId } : {}),
+                    ...(sideText ? { textOutput: sideText } : {}),
+                    attachments,
+                    attempts,
+                },
+            };
+        },
+    };
+}