@chipschat/hermes 1.0.10 → 1.0.12

package/README.md

@@ -218,7 +218,9 @@ the key it kept. The scratch Chips, the link and the run come from Chips's `tool
 ## Release
 
 `npm run release` builds `dist/main.js`, one file with the SDK and everything else bundled in, and
-`dist/THIRD-PARTY-NOTICES.md` beside it; runs the tests; and packs `chipschat-hermes-<version>.tgz`. `npm publish`
-publishes it. A version's major is the Chips protocol it speaks, and Chips's card names that major
-(Chips ADR 0218): a fix is a minor or a patch, and reaches every card of its major the day it is
-published.
+`dist/THIRD-PARTY-NOTICES.md` beside it; runs the tests; and packs `chipschat-hermes-<version>.tgz`. To publish,
+change `version` in package.json (`npm version <x> --no-git-tag-version`), commit, and push to main:
+`.github/workflows/publish.yml` runs the tests and publishes that version from GitHub with npm's
+trusted publishing, and skips a version npm already has. A version's major is the Chips protocol it
+speaks, and Chips's card names that major (Chips ADR 0218): a fix is a minor or a patch, and reaches
+every card of its major the day it is published.

package/dist/THIRD-PARTY-NOTICES.md

@@ -1,6 +1,6 @@
 # Third-party notices
 
-`dist/main.js` in @chipschat/hermes 1.0.10 carries these packages, bundled in. Each one's
+`dist/main.js` in @chipschat/hermes 1.0.12 carries these packages, bundled in. Each one's
 licence follows.
 
 ## @chipschat/harness 0.0.0 (Apache-2.0)

package/dist/main.js

@@ -23807,6 +23807,14 @@ var Run = class {
       ...cost2(input2.costUsd)
     });
   }
+  /**
+   * That this turn heard a message said in the room while it worked (ADR 0106): one that
+   * `message.overheard` named this run for in `working_turns`, handed to the turn at a step. The
+   * room shows its agent heard it while working. Say it once the turn has the words, never before.
+   */
+  heard(messageId) {
+    return this.wire.send("message.heard", { message_id: messageId });
+  }
   checkpoint(label2, next, compacted) {
     return this.wire.send("checkpoint", {
       label: label2,
@@ -24838,6 +24846,25 @@ function connect(options) {
   return Chips.connect(options);
 }
 
+// node_modules/@chipschat/harness/dist/heard.js
+function workingTurnsOf(message) {
+  return (message.working_turns ?? []).map((turn) => ({
+    agentId: turn.agent_id,
+    runId: turn.run_id
+  }));
+}
+function overheardLine(message) {
+  const files = message.attachments ?? [];
+  const said2 = files.flatMap((file3) => file3.transcript === void 0 ? [] : [file3.transcript]);
+  const words4 = [
+    message.text.trim(),
+    ...said2.map((each) => `(voice note: ${each})`),
+    files.length === 0 ? "" : `(sent ${files.map((file3) => file3.filename).join(", ")})`
+  ].filter((part) => part !== "");
+  const who = withRole(message.from.display_name, message.from);
+  return `${who} said in the room, not to you: ${words4.join(" ")}`;
+}
+
 // node_modules/@chipschat/harness/dist/join.js
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -27475,6 +27502,8 @@ var Bridge = class {
   options;
   agents = [];
   rooms = /* @__PURE__ */ new Map();
+  /** The turns going, by their Chips run, for what is said in their rooms while they work (Chips ADR 0106). */
+  working = /* @__PURE__ */ new Map();
   /** Every Chips agent of the harness's, configured here or not. */
   ours = /* @__PURE__ */ new Set();
   /** The harness's agents' names, by Chips id, for the folders named after them. */
@@ -27522,6 +27551,7 @@ var Bridge = class {
     }
     this.ours = /* @__PURE__ */ new Set([...known.map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
     chips2.on("message.new", (message) => void this.hear(message));
+    chips2.on("message.overheard", (message) => void this.overheard(message));
     chips2.on("agent.asked", (asked) => {
       this.making = this.making.then(() => this.make(asked)).catch((error62) => this.log(`a new agent went wrong: ${messageOf3(error62)}`));
     });
@@ -28138,8 +28168,20 @@ ${hook.lines}`);
       counted: 0,
       approvals: /* @__PURE__ */ new Map(),
       allowed: [],
-      interrupted: false
+      interrupted: false,
+      overheard: []
     };
+    this.working.set(run2.id, turn);
+    try {
+      await this.take(turn, room, { message, speakerId, sayWho });
+    } finally {
+      this.working.delete(run2.id);
+    }
+  }
+  /** A turn begun: Hermes's runs of it, from the first words to its end. */
+  async take(turn, room, { message, speakerId, sayWho }) {
+    const { agent } = room;
+    const { run: run2 } = turn;
     run2.on("cancel", () => {
       turn.cancelled = true;
       if (turn.hermesRun !== "") void agent.client.stop(turn.hermesRun).catch(() => void 0);
@@ -28192,12 +28234,46 @@ ${hook.lines}`);
       return void 0;
     }
     if (turn.cancelled) await agent.client.stop(turn.hermesRun).catch(() => void 0);
+    let last;
     try {
-      const last = await agent.client.events(turn.hermesRun, (event) => this.heard(turn, event));
-      return last ?? await this.endOf(turn);
+      last = await agent.client.events(turn.hermesRun, (event) => this.heard(turn, event)) ?? await this.endOf(turn);
     } catch (error62) {
       this.log(`lost ${agent.config.name}'s run ${turn.hermesRun}: ${messageOf3(error62)}`);
-      return await this.endOf(turn);
+      last = await this.endOf(turn);
+    }
+    await this.toldWhileWorking(turn, last);
+    return last;
+  }
+  /**
+   * Words said in a room, not to the harness, while its agents work there (Chips ADRs 0105, 0106):
+   * each turn Chips names hears them as a steer of its Hermes run, which Hermes gives the model
+   * after the step it is on. A run that won't take a steer is ending, and its agent's next turn is
+   * handed the words.
+   */
+  async overheard(message) {
+    const line2 = overheardLine(message);
+    for (const { runId } of workingTurnsOf(message)) {
+      const turn = this.working.get(runId);
+      if (turn === void 0 || turn.run.over || turn.hermesRun === "") continue;
+      try {
+        await turn.agent.client.steer(turn.hermesRun, line2);
+        turn.overheard.push({ messageId: message.message_id, line: line2 });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Which of the words steered into a run it heard: those Hermes gave it before it completed, not
+   * those it kept back as `pending_steer`, nor any in a run that failed or was stopped. Chips is
+   * told of each, and the room shows the agent heard it while working (Chips ADR 0106).
+   */
+  async toldWhileWorking(turn, last) {
+    const told = turn.overheard.splice(0);
+    if (last?.event !== "run.completed") return;
+    const kept = typeof last["pending_steer"] === "string" ? last["pending_steer"] : "";
+    for (const { messageId, line: line2 } of told) {
+      if (kept.includes(line2)) continue;
+      await turn.run.heard(messageId).catch((error62) => this.log(`couldn't say a turn heard ${messageId}: ${messageOf3(error62)}`));
     }
   }
   /** The end of a run whose stream was lost: its state read until it is over, as a terminal event. */

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@chipschat/hermes",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Hermes Agent as a Chips harness, on its Runs API: each profile a Chips agent, each room a Hermes session.",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arjungupta99/chips-hermes.git"
+  },
   "type": "module",
   "engines": {
     "node": ">=22.19.0"