sakura-agent 0.1.1 → 0.1.2

package/dist/packages/plugins/review/src/reviewer.js

@@ -33,75 +33,163 @@ export function outcomeFor(risk, authorization) {
         return authorization === "high" || authorization === "medium" ? "allow" : "deny";
     return "deny";
 }
-const clip = (text, max = 2000) => (text.length > max ? `${text.slice(0, max)}… [cut]` : text);
+export const defaultReviewerLimits = { maxThreadTokens: 24_000, recentUserMessages: 5, digestVerdicts: 10, entryChars: 1200, instructionChars: 4000, actionChars: 6000 };
+/** The limits with the defaults filled in; throws when one is not a positive whole number (a mistake in the definition is found at the definition). */
+export function resolveReviewerLimits(given = {}) {
+    const limits = { ...defaultReviewerLimits };
+    for (const key of Object.keys(defaultReviewerLimits)) {
+        const value = given[key];
+        if (value === undefined)
+            continue;
+        if (!Number.isInteger(value) || value < 1)
+            throw new RangeError(`review: ${key} must be a whole number of at least 1, got ${String(value)}`);
+        limits[key] = value;
+    }
+    return limits;
+}
+/** At most `max` characters: the beginning and the end, with a note of how much was left out between them. */
+export function shorten(text, max) {
+    if (text.length <= max)
+        return text;
+    const note = (left) => `… [${left} characters left out] …`;
+    const room = Math.max(2, max - note(text.length).length);
+    const head = Math.ceil(room / 2);
+    const tail = Math.floor(room / 2);
+    return `${text.slice(0, head)}${note(text.length - head - tail)}${text.slice(text.length - tail)}`;
+}
+const clip = shorten;
 const textOf = (content) => content.map((part) => (part.type === "text" ? part.text : part.type === "image" ? "[image]" : "")).join("");
 /**
  * What the reviewer is told since the last time: the user's words, project instructions and goal, and the tool
  * calls the agent made. Tool results and the agent's own text are left out on purpose.
  */
-export function transcriptDelta(entries, from, skipCallId) {
+export function transcriptDelta(entries, from, skipCallId, limits = defaultReviewerLimits) {
     const lines = [];
     for (const entry of entries.slice(from)) {
         if (entry.type === "custom_message") {
             const label = entry.customType === "goal" ? "goal" : entry.customType === "agents_md" ? "project instructions" : entry.customType;
-            lines.push(`[${label}] ${clip(textOf(entry.content), 6000)}`);
+            lines.push(`[${label}] ${clip(textOf(entry.content), limits.instructionChars)}`);
         }
         else if (entry.type === "message" && entry.message.role === "user") {
-            lines.push(`[user] ${clip(textOf(entry.message.content))}`);
+            lines.push(`[user] ${clip(textOf(entry.message.content), limits.entryChars)}`);
         }
         else if (entry.type === "message" && entry.message.role === "assistant") {
             for (const part of entry.message.content) {
                 if (part.type === "tool_call" && part.id !== skipCallId)
-                    lines.push(`[agent tool call] ${part.name} ${clip(JSON.stringify(part.args ?? {}))}`);
+                    lines.push(`[agent tool call] ${part.name} ${clip(JSON.stringify(part.args ?? {}), limits.entryChars)}`);
             }
         }
     }
     return lines;
 }
+/** One line per earlier verdict, from the `review` records in the log: the last `limit` of them, oldest first. A review that failed technically is not a verdict. */
+export function verdictDigest(entries, limit) {
+    const lines = [];
+    for (const entry of entries) {
+        if (entry.type !== "custom" || entry.customType !== "review")
+            continue;
+        const data = entry.data;
+        if (!data || data.technical === true || typeof data.tool !== "string" || (data.outcome !== "allow" && data.outcome !== "deny"))
+            continue;
+        const reason = typeof data.reason === "string" ? data.reason.replace(/\s+/g, " ").trim() : "";
+        lines.push(`[earlier review] ${data.tool}: ${data.outcome}${reason ? ` - ${shorten(reason, 160)}` : ""}`);
+    }
+    return lines.slice(-limit);
+}
+/**
+ * What a new conversation starts with: the active goal, the project instructions, the latest few user messages and the digest of the latest verdicts.
+ * Everything before is left out, and the reviewer is told so.
+ */
+export function seedLines(entries, limits) {
+    const withdrawn = new Set(entries.flatMap((entry) => (entry.type === "context_edit" && entry.replacement === null ? [entry.targetId] : [])));
+    const newest = (customType) => entries.findLast((entry) => entry.type === "custom_message" && entry.customType === customType && !withdrawn.has(entry.id));
+    const lines = ["(Earlier parts of the conversation are left out. What follows is the project's instructions, the goal, the latest user messages and the latest verdicts.)"];
+    const instructions = newest("agents_md");
+    const goal = newest("goal");
+    if (instructions?.type === "custom_message")
+        lines.push(`[project instructions] ${clip(textOf(instructions.content), limits.instructionChars)}`);
+    if (goal?.type === "custom_message")
+        lines.push(`[goal] ${clip(textOf(goal.content), limits.instructionChars)}`);
+    const users = entries.flatMap((entry) => (entry.type === "message" && entry.message.role === "user" ? [`[user] ${clip(textOf(entry.message.content), limits.entryChars)}`] : []));
+    lines.push(...users.slice(-limits.recentUserMessages), ...verdictDigest(entries, limits.digestVerdicts));
+    return lines;
+}
+/** The review is asked twice at most: a second try for a technical failure (timeout, error, unreadable answer). */
+const ATTEMPTS = 2;
+/** `{ usage }` when the reviewer spent any tokens, otherwise nothing. */
+const usageOf = (spent) => (spent.input + spent.output + spent.cacheRead + spent.cacheWrite > 0 ? { usage: spent } : {});
+/** Four characters to a token, as everywhere else. */
+const estimatedTokens = (texts) => Math.ceil(texts.reduce((sum, text) => sum + text.length, 0) / 4);
 const userMessage = (text) => ({ role: "user", content: [{ type: "text", text }], ts: 0 });
 /**
  * A model asks "may this run?". One conversation per log is kept and only ever appended to, so the provider's
- * prompt cache keeps working. Anything unexpected (timeout, unreadable answer, error) is a refusal.
+ * prompt cache keeps working. Anything unexpected (timeout, unreadable answer, error) is tried once more and then refused, marked as a technical failure.
  */
 export function createReviewer(options) {
     const system = reviewerSystemPrompt(options.policy);
     const timeoutMs = options.timeoutMs ?? 90_000;
+    const limits = resolveReviewerLimits(options.limits);
     const threads = new WeakMap();
     const queues = new WeakMap();
+    /** One request to the reviewer model; returns its text and adds the tokens it used to `spent`. Throws on a timeout or an error. */
+    async function ask(messages, runSignal, spent) {
+        const signal = AbortSignal.any([runSignal, AbortSignal.timeout(timeoutMs)]);
+        let answer = "";
+        for await (const event of options.llm.stream({ system, messages, tools: [], maxTokens: 1000 }, signal)) {
+            if (event.type === "text_delta")
+                answer += event.delta;
+            else if (event.type === "usage") {
+                spent.input += event.usage.input;
+                spent.output += event.usage.output;
+                spent.cacheRead += event.usage.cacheRead;
+                spent.cacheWrite += event.usage.cacheWrite;
+            }
+        }
+        return answer;
+    }
     async function review(call, context) {
         const entries = await context.log.branch();
-        const thread = threads.get(context.log) ?? { messages: [], cursor: 0 };
-        const delta = transcriptDelta(entries, thread.cursor, call.id);
-        const prompt = (delta.length > 0 ? `<context>\n${delta.join("\n")}\n</context>\n\n` : "") + `<action>\ntool: ${call.name}\narguments: ${clip(JSON.stringify(call.args ?? {}), 4000)}\n</action>`;
+        const known = threads.get(context.log) ?? { messages: [], cursor: 0 };
+        const action = `<action>\ntool: ${call.name}\narguments: ${shorten(JSON.stringify(call.args ?? {}), limits.actionChars)}\n</action>`;
+        const promptFor = (lines) => (lines.length > 0 ? `<context>\n${lines.join("\n")}\n</context>\n\n` : "") + action;
+        // The conversation only grows, so the provider's cache keeps working, until it is too big or its basis changed; then a new one starts from a seed.
+        const rewritten = entries.length < known.cursor || entries.slice(known.cursor).some((entry) => entry.type === "compaction");
+        let thread = rewritten ? { messages: [], cursor: 0 } : known;
+        let prompt = promptFor(thread.messages.length === 0 ? seedLines(entries, limits) : transcriptDelta(entries, thread.cursor, call.id, limits));
+        if (thread.messages.length > 0 && estimatedTokens([system, ...thread.messages.map((message) => textOf(message.content)), prompt]) > limits.maxThreadTokens) {
+            thread = { messages: [], cursor: 0 };
+            prompt = promptFor(seedLines(entries, limits));
+        }
         const messages = [...thread.messages, userMessage(prompt)];
+        // a technical failure is tried once more; what the attempts cost is counted either way
+        const spent = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        let failure = "";
         let answer = "";
-        try {
-            const signal = AbortSignal.any([context.signal, AbortSignal.timeout(timeoutMs)]);
-            for await (const event of options.llm.stream({ system, messages, tools: [], maxTokens: 1000 }, signal)) {
-                if (event.type === "text_delta")
-                    answer += event.delta;
+        let assessment;
+        for (let attempt = 1; attempt <= ATTEMPTS && !assessment; attempt++) {
+            try {
+                answer = await ask(messages, context.signal, spent);
+                assessment = parseAssessment(answer);
+                if (!assessment)
+                    failure = "it gave an answer that could not be read";
+            }
+            catch (error) {
+                if (context.signal.aborted)
+                    return { kind: "deny", reason: "The run was stopped during the safety review, so the action was not allowed.", technical: true, ...usageOf(spent) };
+                const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+                failure = timedOut ? "it did not finish in time" : `it failed (${error instanceof Error ? error.message : "error"})`;
             }
         }
-        catch (error) {
-            const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
-            return {
-                kind: "deny",
-                reason: timedOut
-                    ? "The safety review did not finish in time, so the action was not allowed."
-                    : `The safety review failed (${error instanceof Error ? error.message : "error"}), so the action was not allowed.`,
-            };
-        }
-        const assessment = parseAssessment(answer);
         if (!assessment)
-            return { kind: "deny", reason: "The safety review gave an answer that could not be read, so the action was not allowed." };
+            return { kind: "deny", reason: `The safety review failed technically (${failure}, also on a second try), so the action was not judged and not allowed.`, technical: true, ...usageOf(spent) };
         // keep the conversation append-only: this exchange becomes part of the prefix of the next one
         threads.set(context.log, { messages: [...messages, { role: "assistant", content: [{ type: "text", text: answer }], ts: 0 }], cursor: entries.length });
         const computed = outcomeFor(assessment.risk_level, assessment.user_authorization);
         const outcome = computed === "deny" || assessment.outcome === "deny" ? "deny" : "allow";
         options.onAssessment?.({ call, assessment, outcome });
         return outcome === "allow"
-            ? { kind: "allow", reason: assessment.rationale || "approved by the safety review" }
-            : { kind: "deny", reason: assessment.rationale || `risk ${assessment.risk_level}, user authorization ${assessment.user_authorization}` };
+            ? { kind: "allow", reason: assessment.rationale || "approved by the safety review", ...usageOf(spent) }
+            : { kind: "deny", reason: assessment.rationale || `risk ${assessment.risk_level}, user authorization ${assessment.user_authorization}`, ...usageOf(spent) };
     }
     return {
         name: "reviewer",

package/dist/packages/plugins/tools/src/builtin/image.d.ts

@@ -0,0 +1,11 @@
+/** The image formats that model APIs take. Anything else must be converted or refused before it is sent: a refused image is refused for good. */
+export declare const SENDABLE_IMAGE_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+export type ImageType = (typeof SENDABLE_IMAGE_TYPES)[number] | "image/bmp";
+/** The format a file really has, read from its first bytes (a file name proves nothing). Undefined when it is not an image we know. */
+export declare function sniffImageType(bytes: Uint8Array): ImageType | undefined;
+/**
+ * Turns an uncompressed 24-bit or 32-bit BMP (the kind programs write when they dump a frame) into a PNG. Undefined for anything else: a palette,
+ * run-length coding, 16 bits, unusual colour masks, a truncated file. The caller then tells the model the file cannot be shown. The alpha byte of a
+ * 32-bit BMP is dropped: in this form it is almost always unused (zero) and would make the picture invisible.
+ */
+export declare function bmpToPng(bytes: Uint8Array): Uint8Array | undefined;

package/dist/packages/plugins/tools/src/builtin/image.js

@@ -0,0 +1,84 @@
+import { crc32, deflateSync } from "node:zlib";
+/** The image formats that model APIs take. Anything else must be converted or refused before it is sent: a refused image is refused for good. */
+export const SENDABLE_IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+const startsWith = (bytes, signature, at = 0) => signature.every((value, index) => bytes[at + index] === value);
+/** The format a file really has, read from its first bytes (a file name proves nothing). Undefined when it is not an image we know. */
+export function sniffImageType(bytes) {
+    if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+        return "image/png";
+    if (startsWith(bytes, [0xff, 0xd8, 0xff]))
+        return "image/jpeg";
+    if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38]))
+        return "image/gif"; // "GIF8"
+    if (startsWith(bytes, [0x52, 0x49, 0x46, 0x46]) && startsWith(bytes, [0x57, 0x45, 0x42, 0x50], 8))
+        return "image/webp"; // "RIFF....WEBP"
+    if (startsWith(bytes, [0x42, 0x4d]))
+        return "image/bmp"; // "BM"
+    return undefined;
+}
+/** A guard against a header that promises a picture too large to hold in memory. */
+const MAX_PIXELS = 50_000_000;
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+function pngChunk(type, data) {
+    const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length);
+    const checksum = Buffer.alloc(4);
+    checksum.writeUInt32BE(crc32(body));
+    return Buffer.concat([length, body, checksum]);
+}
+/**
+ * Turns an uncompressed 24-bit or 32-bit BMP (the kind programs write when they dump a frame) into a PNG. Undefined for anything else: a palette,
+ * run-length coding, 16 bits, unusual colour masks, a truncated file. The caller then tells the model the file cannot be shown. The alpha byte of a
+ * 32-bit BMP is dropped: in this form it is almost always unused (zero) and would make the picture invisible.
+ */
+export function bmpToPng(bytes) {
+    if (sniffImageType(bytes) !== "image/bmp" || bytes.length < 54)
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const dataOffset = view.getUint32(10, true);
+    const headerSize = view.getUint32(14, true);
+    if (headerSize < 40)
+        return undefined; // the old 12-byte header is not handled
+    const width = view.getInt32(18, true);
+    const rawHeight = view.getInt32(22, true);
+    const bitsPerPixel = view.getUint16(28, true);
+    const compression = view.getUint32(30, true);
+    const height = Math.abs(rawHeight);
+    const topDown = rawHeight < 0;
+    if (width <= 0 || height === 0 || width * height > MAX_PIXELS)
+        return undefined;
+    if (bitsPerPixel !== 24 && bitsPerPixel !== 32)
+        return undefined;
+    if (compression === 3) {
+        // BI_BITFIELDS: only the usual layout (red 0x00FF0000, green 0x0000FF00, blue 0x000000FF) is understood
+        if (bitsPerPixel !== 32 || bytes.length < 66 || view.getUint32(54, true) !== 0x00ff0000 || view.getUint32(58, true) !== 0x0000ff00 || view.getUint32(62, true) !== 0x000000ff)
+            return undefined;
+    }
+    else if (compression !== 0) {
+        return undefined;
+    }
+    const bytesPerPixel = bitsPerPixel / 8;
+    const rowSize = Math.ceil((width * bitsPerPixel) / 32) * 4;
+    if (dataOffset + rowSize * height > bytes.length)
+        return undefined;
+    // PNG rows: a filter byte (0 = none) and then red, green, blue for every pixel
+    const scanline = 1 + width * 3;
+    const raw = Buffer.alloc(scanline * height);
+    for (let row = 0; row < height; row++) {
+        const source = dataOffset + (topDown ? row : height - 1 - row) * rowSize;
+        const target = row * scanline + 1;
+        for (let column = 0; column < width; column++) {
+            const pixel = source + column * bytesPerPixel;
+            raw[target + column * 3] = bytes[pixel + 2] ?? 0;
+            raw[target + column * 3 + 1] = bytes[pixel + 1] ?? 0;
+            raw[target + column * 3 + 2] = bytes[pixel] ?? 0;
+        }
+    }
+    const header = Buffer.alloc(13);
+    header.writeUInt32BE(width, 0);
+    header.writeUInt32BE(height, 4);
+    header[8] = 8; // bit depth
+    header[9] = 2; // colour type: truecolour
+    return new Uint8Array(Buffer.concat([PNG_SIGNATURE, pngChunk("IHDR", header), pngChunk("IDAT", deflateSync(raw)), pngChunk("IEND", Buffer.alloc(0))]));
+}

package/dist/packages/plugins/tools/src/builtin/read.js

@@ -1,14 +1,23 @@
 import { DEFAULT_FOLD, foldHead } from "../fold.js";
 import { ArgumentError, optionalInteger, requireString } from "./args.js";
-const IMAGE_TYPES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp" };
+import { bmpToPng, SENDABLE_IMAGE_TYPES, sniffImageType } from "./image.js";
+/** File names that say "this is a picture". What the file really is, is decided by its first bytes (image.ts). */
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
+const CONVERTED_DIRECTORY = ".sakura/artifacts";
 const fail = (text) => ({ content: [{ type: "text", text }], isError: true });
 const ok = (text) => ({ content: [{ type: "text", text }] });
+const imageResult = (mediaType, ref, note = "") => ({
+    content: [
+        { type: "text", text: `Read image file [${mediaType}]${note ? ` (${note})` : ""}` },
+        { type: "image", mediaType, ref },
+    ],
+});
 /*
  * Description adapted from Pi's read tool (MIT, Copyright (c) 2025 Mario Zechner; see THIRD_PARTY_NOTICES.md).
  */
 export const readTool = {
     name: "read",
-    description: "Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp); images are sent as attachments. " +
+    description: "Read the contents of a file. Supports text files and images (jpg, png, gif, webp; a plain bmp is converted to png); images are sent as attachments. " +
         "For text files, output is truncated to the first 2000 lines or 50KB, whichever is hit first. " +
         "Use offset and limit for large files, and continue with offset until you have the whole file.",
     parameters: {
@@ -21,7 +30,7 @@ export const readTool = {
         required: ["path"],
     },
     effect: "read",
-    async execute(args, { env }) {
+    async execute(args, { env, callId }) {
         try {
             const path = requireString(args, "path");
             const offset = optionalInteger(args, "offset", 1);
@@ -33,16 +42,21 @@ export const readTool = {
             if (info.isDirectory)
                 return fail(`${path} is a directory, not a file.`);
             const extension = absolute.slice(absolute.lastIndexOf(".")).toLowerCase();
-            const mediaType = IMAGE_TYPES[extension];
-            if (mediaType) {
-                return {
-                    content: [
-                        { type: "text", text: `Read image file [${mediaType}]` },
-                        { type: "image", mediaType, ref: absolute },
-                    ],
-                };
-            }
             const bytes = await env.readFile(absolute);
+            if (IMAGE_EXTENSIONS.has(extension)) {
+                const type = sniffImageType(bytes);
+                if (type && SENDABLE_IMAGE_TYPES.includes(type))
+                    return imageResult(type, absolute);
+                if (type === "image/bmp") {
+                    const png = bmpToPng(bytes);
+                    if (!png)
+                        return fail(`${path} is a BMP image in a form this tool cannot convert, and the model API does not accept BMP. Convert it to PNG with a command (for example ImageMagick: magick ${path} out.png) and read the PNG.`);
+                    const converted = `${CONVERTED_DIRECTORY}/read-${callId.replace(/[^A-Za-z0-9_.-]/g, "_")}.png`;
+                    await env.writeFile(converted, png);
+                    return imageResult("image/png", env.resolve(converted), `converted from BMP to PNG, original ${path}`);
+                }
+                // a name that says picture, bytes that are not one: shown as the binary or text file it is
+            }
             if (bytes.subarray(0, 8000).includes(0))
                 return fail(`${path} looks like a binary file and cannot be shown as text.`);
             const text = new TextDecoder().decode(bytes);

package/dist/packages/session/src/projection.js

@@ -1,4 +1,6 @@
 import { COMPACTION_PREFIX } from "../../kernel/src/index.js";
+/** The message that tells the model about its goal. It is the one pinned message that does not sit in front: see `projectMessages`. */
+const isGoalStatement = (entry) => entry?.type === "custom_message" && entry.customType === "goal";
 function entryToMessage(entry) {
     if (entry.type === "message")
         return entry.message;
@@ -55,27 +57,42 @@ function orderToolResults(messages) {
     }
     return ordered;
 }
+/** The goal statement still in force that lies before `start` (so the compaction took it out of the visible history), as a message. */
+function goalCompactedAway(branch, start, edits) {
+    for (let index = start - 1; index >= 0; index--) {
+        const entry = branch[index];
+        if (!entry || !isGoalStatement(entry))
+            continue;
+        return edits.get(entry.id) === null ? undefined : entryToMessage(entry);
+    }
+    return undefined;
+}
 export function projectMessages(branch) {
     const { start, summary, compactedAt } = findStart(branch);
     const edits = collectEdits(branch);
     const messages = [];
-    // Pinned entries (project instructions) stay in front even after compaction.
+    // Pinned entries (project instructions) stay in front even after compaction. They are written once, at the start, so the front never changes.
+    // The goal is pinned too, but it is set in the middle of a conversation: in front it would change everything after it and cost the provider's
+    // prompt cache. It stays where it was written, and after a compaction it follows the summary.
     for (let index = 0; index < branch.length; index++) {
         const entry = branch[index];
-        if (entry?.type !== "custom_message" || !entry.pinned)
+        if (entry?.type !== "custom_message" || !entry.pinned || isGoalStatement(entry))
             continue;
         if (edits.get(entry.id) === null)
-            continue; // a pinned message can be withdrawn too (an earlier goal)
+            continue; // a pinned message can be withdrawn too
         const message = entryToMessage(entry);
         if (message)
             messages.push(message);
     }
     if (summary !== undefined) {
         messages.push({ role: "user", content: [{ type: "text", text: `${COMPACTION_PREFIX}\n\n${summary}` }], ts: 0 });
+        const carried = goalCompactedAway(branch, start, edits);
+        if (carried)
+            messages.push(carried);
     }
     for (let index = start; index < branch.length; index++) {
         const entry = branch[index];
-        if (!entry || (entry.type === "custom_message" && entry.pinned))
+        if (!entry || (entry.type === "custom_message" && entry.pinned && !isGoalStatement(entry)))
             continue;
         const message = entryToMessage(entry);
         if (!message)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sakura-agent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "workspaces": [
@@ -23,7 +23,8 @@
     "example": "node examples/quickstart.ts",
     "build": "node scripts/build-sdk.mjs",
     "prepack": "npm run build",
-    "example:tools": "node examples/tools.ts"
+    "example:tools": "node examples/tools.ts",
+    "example:fleet": "node examples/fleet.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.6.4",