@rien7/agent-center-host 0.1.0 → 0.1.1

package/README.md

@@ -184,6 +184,13 @@ plus the runtime's file tools for memory (pi `read/edit/write`; Claude Code
   run again are kept in `<workdir>/resumed-turns.json`).
 - Core runs one turn per agent at a time, so a second message waits for the first (the
   driver also handles oar's steer/queue landings for when that changes).
+- **Inactive history.** When the session compacts (oar `compaction_ended`, completed),
+  the host calls `agent.history.mark_inactive` with `beforeTurnId` (the tool calls of every
+  earlier turn of the agent) and the calls the current turn made so far; the messages stay
+  (the summary keeps them). When oar drops an accepted input (`input_dropped`; oar 0.86
+  has no other rollback record), that turn fails and its user message, reply and tool calls
+  are marked inactive. The mark waits for the turn's queued events to reach Center.
+  `search.query` and `message.list` leave inactive records out unless `includeInactive`.
 
 `Ctrl-C` flushes queued events, marks the host's agents offline and leaves any running
 turn running. The next `run` resumes it.
@@ -293,6 +300,8 @@ bun test packages/agent-host     # core in-process over real HTTP + the host loo
                                  # oar-driver.test.ts: pi + the mock model, end to end
                                  # subagents.test.ts: issued tokens, memory notes,
                                  #   sub-agents, presence, interrupted turns
+                                 # inactive.test.ts: compaction / dropped input →
+                                 #   inactive history (fake oar session)
 bun x tsc -p packages/agent-host # typecheck against Node types
 ```
 

package/dist/core-client.js

@@ -63,6 +63,9 @@ export class HttpCoreClient {
     openTurn(input) {
         return this.op("turn.open", input, `open-${input.id}`);
     }
+    markInactive(input) {
+        return this.op("history.mark_inactive", input);
+    }
     async claim(input) {
         return (await this.op("turn.claim", input)).items;
     }

package/dist/host.js

@@ -397,6 +397,7 @@ export class AgentHost {
                     terminal = true;
                 batcher.push(event);
             },
+            flushed: () => batcher.flush(),
         };
         active.settled = (async () => {
             try {

package/dist/oar-driver.js

@@ -90,6 +90,10 @@ function textSink(sink, holdMs = 100) {
             flush();
             sink.emit(event);
         },
+        flushed() {
+            flush();
+            return sink.flushed?.() ?? Promise.resolve();
+        },
     };
 }
 const clip = (text, max) => {
@@ -146,6 +150,12 @@ class AgentRun {
     pending = [];
     /** The owner of the oar turn that ended last (its report follows). */
     lastEnded = null;
+    /** The owner the runtime's events went to last (a compaction while idle covers it). */
+    lastOwner = null;
+    /** Core turns this run delivered (input ids), newest last; bounded. */
+    turnIds = new Set();
+    /** history.mark_inactive calls in flight, in order. */
+    marking = Promise.resolve();
     /** Its conversation with its parent. */
     conversationId = null;
     // A parent:
@@ -422,7 +432,11 @@ export class OarDriver {
             finished: false,
             chain: Promise.resolve(),
             resolve: () => { },
+            calls: [],
         };
+        run.turnIds.add(owner.turnId);
+        if (run.turnIds.size > 1000)
+            run.turnIds.delete(run.turnIds.values().next().value);
         const ended = new Promise((resolve) => {
             owner.resolve = resolve;
         });
@@ -1130,11 +1144,82 @@ export class OarDriver {
             };
         }
         call.announced = owner;
+        if (!owner.calls.includes(id))
+            owner.calls.push(id);
         this.emit(owner, event);
     }
+    /**
+     * Tell Center which history the runtime no longer has, once the events it names were
+     * appended (behind `owner`'s chain and its sink's batches).
+     */
+    markInactive(run, owner, input, why) {
+        const client = this.client;
+        if (!client?.markInactive)
+            return;
+        const ready = owner
+            ? owner.chain.then(() => owner.sink.flushed?.())
+            : Promise.resolve();
+        run.marking = run.marking
+            .then(() => ready)
+            .then(() => client.markInactive?.(input))
+            .then((marked) => {
+            if (marked && (marked.toolCalls || marked.messages))
+                this.log(`${run.agent.name}: ${why}: ${marked.toolCalls} tool calls, ${marked.messages} messages marked inactive`);
+        })
+            .catch((error) => this.log(`${run.agent.name}: marking ${why} history inactive failed (${error.message})`));
+    }
+    /**
+     * oar `compaction_ended` (completed): the runtime replaced its context with a summary.
+     * Every earlier turn's tool calls and the calls of the turn it happened in are gone
+     * from it.
+     */
+    compacted(run, live) {
+        const owner = live.owners[0] ?? run.lastOwner;
+        if (!owner) {
+            this.log(`${run.agent.name}: the session compacted before any turn here; nothing to mark`);
+            return;
+        }
+        this.markInactive(run, owner, {
+            agentId: run.agent.id,
+            beforeTurnId: owner.turnId,
+            toolCalls: owner.calls.map((callId) => ({
+                turnId: owner.turnId,
+                callId,
+            })),
+        }, "compaction");
+    }
+    /**
+     * oar `input_dropped`: the runtime discarded an input it had accepted, so that turn's
+     * exchange is not in the session's history (oar 0.86 has no rollback record). Its core
+     * turn fails and its messages and tool calls become inactive.
+     */
+    rolledBack(run, live, event) {
+        const inputId = event.inputId;
+        if (!run.turnIds.has(inputId))
+            return;
+        const waiting = live.owners.find((o) => o.turnId === inputId) ?? null;
+        const owner = waiting ?? (run.lastOwner?.turnId === inputId ? run.lastOwner : null);
+        if (waiting)
+            this.finish(live.owners, waiting, {
+                type: "failed",
+                reason: `${run.runtimeId} 丢弃了这条消息${event.reason === "runtime_refused" && event.message
+                    ? `：${event.message}`
+                    : ""}`,
+            });
+        this.markInactive(run, owner, { agentId: run.agent.id, turnIds: [inputId] }, "rollback");
+    }
     onEvent(run, live, event) {
         if (event.agentPath.length)
             return; // the runtime's own sub-agents (Task is off)
+        if (event.kind === "compaction_ended") {
+            if (event.outcome === "completed")
+                this.compacted(run, live);
+            return;
+        }
+        if (event.kind === "input_dropped") {
+            this.rolledBack(run, live, event);
+            return;
+        }
         if (event.kind === "exited") {
             for (const owner of [...live.owners])
                 this.finish(live.owners, owner, {
@@ -1158,6 +1243,7 @@ export class OarDriver {
         const owner = live.owners[0];
         if (!owner)
             return;
+        run.lastOwner = owner;
         switch (event.kind) {
             case "text_delta":
                 if (event.text)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rien7/agent-center-host",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "description": "Agent host for Agent Center: claims queued turns and answers them through a driver (an oar runtime: Claude Code, pi; or echo). Node 24+.",
   "keywords": [