@bivy/bivy 0.20.9-staging.25 → 0.20.9-staging.26

package/dist/agent-instructions.js

@@ -38,7 +38,8 @@ export const BIVY_AGENT_NOTE = [
         "rule. A `.csv`/`.tsv` renders as a table; anything else arrives as a download.",
     "- Show a NUMBER or a CHART inside your reply: fence a spec as ```bivy. A number is " +
         '`{"type":"metric","value":"4 650 kWh","label":"per year"}`; a chart is a plain Vega-Lite spec with its data ' +
-        "inline (`{\"mark\":\"bar\",\"data\":{\"values\":[…]},\"encoding\":{…}}`). A chart cannot fetch a URL — put the data in the spec.",
+        "inline, or pointing at a workspace data file with `\"data\":{\"url\":\"data/use.csv\"}` (.csv/.tsv/.json). " +
+        "A chart cannot fetch a remote URL.",
     "- Send a file WITHOUT writing a reply (or from a script): run " +
         '`bivy attach <path> [--caption "short note"]`, or call the `attach_to_chat` tool if you have it.',
     "- Something with a UI: `bivy app publish <manifest.json>` (a web server's port, a static build, a terminal) or " +

package/dist/session/message-components.js

@@ -292,11 +292,85 @@ export function componentKind(opts) {
     // show that yet".
     return "file";
 }
+/** How deep into a spec to look for references. Bounded so a pathological
+ *  nesting cannot turn one message into an unbounded walk. */
+const MAX_SPEC_DEPTH = 8;
 /**
- * Every reference a message makes that Bivy has to resolve — from image syntax
- * or from a directive — de-duplicated, in first-seen order, under ONE shared
- * cap. One budget across both forms is deliberate: the cost being bounded is
- * file reads and persisted bytes, which do not care which syntax asked.
+ * Workspace files a SPEC references, by putting a relative path in a `url`
+ * field. That is Vega-Lite's `data.url`, which is how a chart points at a
+ * dataset rather than carrying every row inline — and the whole spec is walked
+ * because Vega-Lite allows one per layer, facet and lookup, not just at the top.
+ *
+ * Deliberately keyed on the field NAME, not on anything Vega-specific: this
+ * file must not learn one kind's schema, and "a `url` field holding a
+ * workspace path is a reference" is a rule any future kind can use.
+ *
+ * A `url` that is not a workspace path (an `https://` address, say) is not
+ * returned, and so is never resolved — the view layer refuses those outright
+ * rather than letting a chart make the reader's browser fetch it.
+ */
+export function specReferences(spec, limit = MAX_COMPONENTS_PER_MESSAGE) {
+    const out = [];
+    const seen = new Set();
+    const walk = (value, depth) => {
+        if (out.length >= limit || depth > MAX_SPEC_DEPTH || !value || typeof value !== "object")
+            return;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, depth + 1);
+            return;
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "url" && typeof child === "string") {
+                const ref = unescapeComponentRef(child);
+                if (classifyImageTarget(ref) === "workspace" && !seen.has(ref)) {
+                    seen.add(ref);
+                    out.push(ref);
+                    if (out.length >= limit)
+                        return;
+                }
+                continue;
+            }
+            walk(child, depth + 1);
+        }
+    };
+    walk(spec, 0);
+    return out;
+}
+/** Each ```bivy fence in `text`, as a parsed spec with its offset. Line-wise,
+ *  because that is how a fence is defined; an unterminated one yields nothing,
+ *  which is also how a half-streamed message behaves. */
+function componentFences(text) {
+    const out = [];
+    const lines = String(text).split("\n");
+    let at = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const start = at;
+        at += line.length + 1;
+        if (!isComponentFence(line.trim().replace(/^```+/, "")))
+            continue;
+        const body = [];
+        let j = i + 1;
+        for (; j < lines.length && !lines[j].trim().startsWith("```"); j++) {
+            body.push(lines[j]);
+            at += lines[j].length + 1;
+        }
+        if (j < lines.length)
+            at += lines[j].length + 1;
+        const spec = parseComponentSpec(body.join("\n"));
+        if (spec)
+            out.push({ spec, at: start });
+        i = j;
+    }
+    return out;
+}
+/**
+ * Every reference a message makes that Bivy has to resolve — from image syntax,
+ * from a directive, or from a `url` inside a spec — de-duplicated, in first-seen
+ * order, under ONE shared cap. One budget across all three forms is deliberate:
+ * the cost being bounded is file reads and persisted bytes, which do not care
+ * which syntax asked.
  */
 export function extractMessageReferences(text, limit = MAX_COMPONENTS_PER_MESSAGE) {
     if (!text)
@@ -322,6 +396,12 @@ export function extractMessageReferences(text, limit = MAX_COMPONENTS_PER_MESSAG
             found.push({ ref: directive.ref, origin: "workspace", syntax: "view", at });
         at += line.length + 1;
     }
+    // A spec can point at a dataset instead of carrying it (a chart's data.url).
+    for (const { spec, at: offset } of componentFences(source)) {
+        for (const ref of specReferences(spec, limit)) {
+            found.push({ ref, origin: "workspace", syntax: "spec", at: offset });
+        }
+    }
     found.sort((a, b) => a.at - b.at);
     const out = [];
     const seen = new Set();

package/dist/session/transcript-persistence.js

@@ -127,13 +127,31 @@ export function createTranscriptPersistence(deps) {
         }
         return refs;
     }
+    /** References made by the NEWEST assistant message. These are re-read even
+     *  when the log already has them, which is what lets an agent overwrite a
+     *  file and reference it again; see resolveWorkspaceRefs. */
+    function refsInLatestMessage(record) {
+        const messages = record.session.getMessages();
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if (m.role !== "assistant")
+                continue;
+            return new Set(extractWorkspaceRefs(assistantTextForImageScan(m.content)).map(({ ref }) => ref));
+        }
+        return new Set();
+    }
     /** Store resolved bytes under `ref` and tell every client, durably and live.
      *  One place, so the remote and workspace resolvers below cannot drift in how
      *  they record what they found. `kind` carries whether the bytes are an image,
      *  which is what lets the view layer pick a renderer for a `::view` that
      *  points at something other than a picture. */
-    function recordResolvedRef(sessionId, ref, bytes, meta) {
+    function recordResolvedRef(sessionId, ref, bytes, meta, previousHash) {
         const stored = attachmentStore.put(bytes, { name: meta.name, mimeType: meta.mimeType, kind: meta.kind ?? "image" });
+        // Content-addressed, so re-reading an unchanged file yields the hash
+        // already recorded. Appending that again would grow the log and wake every
+        // device for a picture none of them would redraw.
+        if (previousHash && stored.hash === previousHash)
+            return;
         eventLog.appendInlineImage(sessionId, { url: ref, ref: stored });
         eventLog.flush(sessionId);
         deps.broadcast(deps.stampSessionEvent({ type: "session.event", sessionId, event: { type: "inlineImage", url: ref, ref: stored } }));
@@ -166,12 +184,24 @@ export function createTranscriptPersistence(deps) {
         const refs = workspaceRefsInTranscript(record);
         if (!refs.size)
             return;
-        const alreadyResolved = new Set(eventLog.readInlineImages(record.id).map(([ref]) => ref));
+        const resolved = new Map(eventLog.readInlineImages(record.id));
+        // References the agent just made are re-read even when the log already has
+        // them. An agent that regenerates out/chart.png and shows it again means
+        // the new one; without this it would say "here is the updated chart" above
+        // the old picture. Bounded to the newest message, so this costs at most the
+        // per-message reference budget in reads per turn rather than re-reading
+        // every file the whole session ever mentioned.
+        const fresh = refsInLatestMessage(record);
         for (const [rel, syntax] of refs) {
-            if (alreadyResolved.has(rel))
+            const previous = resolved.get(rel);
+            const isFresh = fresh.has(rel);
+            if (previous && !isFresh)
                 continue;
             const failedAt = inlineImageFailedAt.get(rel);
-            if (failedAt !== undefined && Date.now() - failedAt < INLINE_IMAGE_RETRY_COOLDOWN_MS)
+            // A fresh reference ignores the cooldown: the likeliest reason it failed
+            // before is that the agent had not written the file yet, and waiting ten
+            // minutes to show a file that now exists is worse than one extra read.
+            if (!isFresh && failedAt !== undefined && Date.now() - failedAt < INLINE_IMAGE_RETRY_COOLDOWN_MS)
                 continue;
             const plan = planAttachment({ workspaceDir, filePath: rel, maxBytes: MAX_WORKSPACE_REF_BYTES });
             if (isAttachPlanError(plan)) {
@@ -189,7 +219,7 @@ export function createTranscriptPersistence(deps) {
                 continue;
             }
             try {
-                recordResolvedRef(record.id, rel, plan.bytes, { name: plan.name, mimeType: plan.mimeType, kind: plan.kind });
+                recordResolvedRef(record.id, rel, plan.bytes, { name: plan.name, mimeType: plan.mimeType, kind: plan.kind }, previous?.hash);
             }
             catch (error) {
                 console.warn(`[component] ${rel}:`, error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.20.9-staging.25",
+  "version": "0.20.9-staging.26",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",