@guangnao/agent-os 1.0.0 → 1.0.1

package/dist/index.js

@@ -1958,13 +1958,98 @@ async function lookup(sys, names, name) {
   }
 }
 
+// src/kernel/blob.ts
+var PAGE = 8 * 1024;
+var GREP_MAX = 50;
+var BlobStore = class {
+  constructor(cap = 4 * 1024 * 1024) {
+    this.cap = cap;
+  }
+  map = /* @__PURE__ */ new Map();
+  // insertion order = LRU age (re-set on touch → newest)
+  seq = 0;
+  bytes = 0;
+  // 4 MB total
+  /** Store content; return a fresh handle. Evict the oldest blobs while over the char cap. */
+  put(content) {
+    const handle = `blob_${(++this.seq).toString(36)}`;
+    this.map.set(handle, content);
+    this.bytes += content.length;
+    while (this.bytes > this.cap && this.map.size > 1) {
+      const [old, v] = this.map.entries().next().value;
+      this.map.delete(old);
+      this.bytes -= v.length;
+    }
+    return handle;
+  }
+  touch(handle) {
+    const v = this.map.get(handle);
+    if (v === void 0) return void 0;
+    this.map.delete(handle);
+    this.map.set(handle, v);
+    return v;
+  }
+  /** A character window of a blob (paged like read_file). */
+  read(handle, offset = 0, limit = PAGE) {
+    const v = this.touch(handle);
+    if (v === void 0) return { error: `unknown blob handle: ${handle}` };
+    const total = v.length;
+    const start = Math.max(0, Math.floor(offset));
+    if (start >= total) return { handle, content: "", total, note: `offset ${start} is at/past end (${total} chars)` };
+    const slice = v.slice(start, start + Math.min(Math.max(1, Math.floor(limit)), PAGE));
+    const end = start + slice.length;
+    return end < total ? { handle, content: slice, truncated: true, total, offset: start, nextOffset: end, note: `chars ${start}\u2013${end} of ${total}; call blob_read with offset=${end} for more` } : { handle, content: slice, total, offset: start };
+  }
+  /** Search a blob for a JS regex; return a short SNIPPET (char offset + surrounding window) per match. Snippet
+   *  rather than whole line because a blob is often one long line (JSON.stringify escapes newlines) — a line view
+   *  would return the entire blob and just overflow again. The offset lets the model blob_read around it. */
+  grep(handle, pattern, max = GREP_MAX) {
+    const v = this.touch(handle);
+    if (v === void 0) return { error: `unknown blob handle: ${handle}` };
+    let re;
+    try {
+      re = new RegExp(pattern, "g");
+    } catch {
+      return { error: `invalid pattern: ${pattern}` };
+    }
+    const PAD = 80, matches = [];
+    let m;
+    while ((m = re.exec(v)) && matches.length < max) {
+      const at = m.index, from = Math.max(0, at - PAD), to = Math.min(v.length, at + m[0].length + PAD);
+      matches.push(`@${at}: ${from > 0 ? "\u2026" : ""}${v.slice(from, to)}${to < v.length ? "\u2026" : ""}`);
+      if (re.lastIndex === at) re.lastIndex++;
+    }
+    return { handle, total: v.length, matches, ...matches.length >= max ? { truncated: true } : {} };
+  }
+};
+var BLOB_TOOLS = [
+  { name: "blob_read", description: "read a window of a large stored tool output by its blob handle (paged like read_file; use when a result said it was stored as blob_\u2026)", parameters: { type: "object", required: ["handle"], properties: {
+    handle: { type: "string", description: "the blob_\u2026 handle from a truncated result" },
+    offset: { type: "number", description: "char index to start at (default 0; use the previous result\u2019s nextOffset)" },
+    limit: { type: "number", description: `max chars (default & cap ${PAGE})` }
+  } } },
+  { name: "blob_grep", description: "find lines matching a JS regex inside a large stored tool output, by blob handle (search without re-reading it all)", parameters: { type: "object", required: ["handle", "pattern"], properties: {
+    handle: { type: "string", description: "the blob_\u2026 handle" },
+    pattern: { type: "string", description: "JS regex, matched per line" }
+  } } }
+];
+var BLOB_NAMES = new Set(BLOB_TOOLS.map((t) => t.name));
+var isBlobTool = (name) => BLOB_NAMES.has(name);
+function execBlobTool(store, name, input) {
+  const a = input ?? {};
+  if (!a.handle) return { error: "handle is required" };
+  if (name === "blob_read") return store.read(a.handle, a.offset, a.limit);
+  if (name === "blob_grep") return a.pattern ? store.grep(a.handle, a.pattern) : { error: "pattern is required" };
+  return { error: `not a blob tool: ${name}` };
+}
+
 // src/userland/agent.ts
 var DEFAULT_SYSTEM = "You are a capable autonomous agent. Break the task into steps and keep going \u2014 investigate with tools, then act \u2014 until it is fully done; never stop at a plan or a partial result. Verify before answering, then reply concisely.";
 var HARD_MAX = 384;
 var MAX_TOOL_CHARS = 8e3;
 var isMessage = (b) => !!b && typeof b.role === "string";
-var capResult = (s) => s.length > MAX_TOOL_CHARS ? s.slice(0, MAX_TOOL_CHARS) + `
-\u2026[truncated ${s.length - MAX_TOOL_CHARS} chars]` : s;
+var capResult = (s, blobs) => s.length <= MAX_TOOL_CHARS ? s : s.slice(0, MAX_TOOL_CHARS) + `
+\u2026[+${s.length - MAX_TOOL_CHARS} chars \u2014 full result stored as ${blobs.put(s)}; call blob_read(handle, offset=${MAX_TOOL_CHARS}) or blob_grep(handle, pattern) for the rest]`;
 function orderForCache(segs) {
   const lead = [], sums = [], rest = [];
   for (const s of segs) (s.pinned && !s.summary ? lead : s.summary ? sums : rest).push(s);
@@ -1992,7 +2077,7 @@ function unproductive(out) {
   const st = o["status"];
   return typeof st === "number" && (st < 200 || st >= 300);
 }
-async function runTurn(sys, llm, tools, spec) {
+async function runTurn(sys, llm, tools, spec, blobs) {
   const ceil = Math.max(1, Math.min(spec.maxSteps ?? HARD_MAX, HARD_MAX));
   const base = Math.max(1, spec.baseSteps ?? 16);
   const stallMax = Math.max(1, spec.stallLimit ?? 3);
@@ -2015,6 +2100,7 @@ async function runTurn(sys, llm, tools, spec) {
     }
     const messages = promptMessages();
     let offer = noTools ? void 0 : spec.tools;
+    if (offer && tools) offer = [...offer, ...BLOB_TOOLS];
     if (steer && offer && del) offer = offer.filter((t) => !del.withhold.includes(t.name));
     const reply = await sys.read(llm, { messages, tools: offer, maxTokens: spec.maxTokens });
     for (const s of sys.workingSet()) {
@@ -2035,13 +2121,15 @@ async function runTurn(sys, llm, tools, spec) {
         }
       }
       if (fresh.length) {
-        const outs = await sys.readAll(tools, fresh.map((f) => f.req));
-        fresh.forEach((f, j) => cache.set(f.key, outs[j]));
+        const viaDevice = fresh.filter((f) => !isBlobTool(f.req.tool));
+        const devOuts = viaDevice.length ? await sys.readAll(tools, viaDevice.map((f) => f.req)) : [];
+        let di = 0;
+        for (const f of fresh) cache.set(f.key, isBlobTool(f.req.tool) ? execBlobTool(blobs, f.req.tool, f.req.input) : devOuts[di++]);
       }
       let progressed = false;
       for (let i = 0; i < calls.length; i++) {
         const out = cache.get(keys[i]);
-        await sys.remember({ role: "tool", toolCallId: calls[i].id, name: calls[i].name, content: capResult(JSON.stringify(out)) });
+        await sys.remember({ role: "tool", toolCallId: calls[i].id, name: calls[i].name, content: capResult(JSON.stringify(out), blobs) });
         if (ran.has(keys[i]) && !unproductive(out)) progressed = true;
       }
       if (del) {
@@ -2092,7 +2180,7 @@ function reactAgent(spec) {
     const { llm, tools, parent } = await openDevices(sys);
     await sys.remember({ role: "system", content: spec.system ?? DEFAULT_SYSTEM }, { pin: true });
     await sys.remember({ role: "user", content: spec.task ?? "" }, { pin: true });
-    const r = await runTurn(sys, llm, tools, spec);
+    const r = await runTurn(sys, llm, tools, spec, new BlobStore());
     if (parent) await sys.send(parent, { $: "result", answer: r.answer, steps: r.steps });
   } };
 }
@@ -2110,13 +2198,14 @@ function conversationAgent(spec = {}) {
     } else {
       await sys.remember({ role: "system", content: spec.system ?? DEFAULT_SYSTEM }, { pin: true });
     }
+    const blobs = new BlobStore();
     for (; ; ) {
       const msg = await sys.recv();
       const userTurn = { role: "user", content: msg.body.task, ...msg.body.images?.length ? { images: msg.body.images } : {} };
       await sys.remember(userTurn);
       let r;
       try {
-        r = await runTurn(sys, llm, tools, spec);
+        r = await runTurn(sys, llm, tools, spec, blobs);
       } catch (e) {
         r = { answer: "", steps: 0, error: e instanceof Error ? e.message : String(e) };
       }

package/dist/kernel/blob.d.ts

@@ -0,0 +1,21 @@
+import type { ToolSchema } from '../drivers/llm';
+export declare class BlobStore {
+    private readonly cap;
+    private readonly map;
+    private seq;
+    private bytes;
+    constructor(cap?: number);
+    /** Store content; return a fresh handle. Evict the oldest blobs while over the char cap. */
+    put(content: string): string;
+    private touch;
+    /** A character window of a blob (paged like read_file). */
+    read(handle: string, offset?: number, limit?: number): unknown;
+    /** Search a blob for a JS regex; return a short SNIPPET (char offset + surrounding window) per match. Snippet
+     *  rather than whole line because a blob is often one long line (JSON.stringify escapes newlines) — a line view
+     *  would return the entire blob and just overflow again. The offset lets the model blob_read around it. */
+    grep(handle: string, pattern: string, max?: number): unknown;
+}
+export declare const BLOB_TOOLS: readonly ToolSchema[];
+export declare const isBlobTool: (name: string) => boolean;
+/** Run a blob_* tool against the store — invoked directly by the agent loop, not the tools device. */
+export declare function execBlobTool(store: BlobStore, name: string, input: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guangnao/agent-os",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AgentOS Kernel — a lightweight, type-safe agent operating system in TypeScript",
   "type": "module",
   "main": "./dist/index.js",