@agentorg/cli 0.0.7 → 0.0.8

package/dist/node_modules/assistant/dist/src/chats.d.ts

@@ -31,8 +31,10 @@ export declare function createChats(options: {
     log: Log;
 }): {
     /**
-     * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
-     * a turn running there takes it at its next model request.
+     * Say a message in a chat, or in a new chat it starts. A new chat's first message is put to
+     * the agent's main loop, which gives it to new work or to work in a turn; from then on the
+     * chat's messages are that work's: with no turn of it running one starts a turn, and a turn
+     * running takes it at its next model request.
      */
     send({ chat, text }: Input<"send">): Promise<{
         chat: string;
@@ -77,14 +79,14 @@ export declare function createChats(options: {
      */
     stop: () => Promise<void>;
     start: () => void;
-    /** Go on with the turns that were cut off when the agent last ran, each once. */
+    /** Go on with what was cut off when the agent last ran, each once: turns, and messages waiting. */
     resume(): Promise<void>;
     /**
-     * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
-     * that opens this store next goes on with them.
+     * Close for good: its turns are cut, and none starts after. They stay marked, as do messages
+     * no work has taken, so the engine that opens this store next goes on with them.
      */
     close: () => Promise<void>;
-    /** Settles when every chat's latest turn has written all it will. */
+    /** Settles when every piece of work's latest turn has written all it will. */
     settled(): Promise<void>;
     /** Streamed text of the model request running now. */
     delta(requestId: string, text: string): void;

package/dist/node_modules/assistant/dist/src/chats.js

@@ -106,10 +106,10 @@ export function createChats(options) {
     /** The chats, by id, once their entries are read. */
     const chats = new Map();
     let loaded;
-    /** The chats whose loops are at work now: the agent is working while there is one. */
-    const atWork = new Set();
-    const stateNow = () => ({ state: atWork.size > 0 ? "working" : "idle" });
-    /** The chats' loops: a chat is the looper's thread of the same name. */
+    /** Whether the agent is working, as its looper last said. */
+    let working = false;
+    const stateNow = () => ({ state: working ? "working" : "idle" });
+    /** The agent's loops: a chat is the looper's thread of the same name. */
     const looper = forChats(createLooper({
         store: forLooper(store),
         model: options.model,
@@ -122,22 +122,18 @@ export function createChats(options) {
                 emit.message({ ...message, chat: thread });
             },
             delta: (thread, id, text) => emit.delta({ chat: thread, id, text }),
-            status(thread, status) {
-                const was = atWork.size > 0;
-                if (status.state === "thinking" || status.state === "tool")
-                    atWork.add(thread);
-                else
-                    atWork.delete(thread);
-                // A turn that failed left its chat's message with no answer: the chat is told why,
-                // before the agent is said to be idle.
+            working(on) {
+                working = on;
+                emit.status(stateNow());
+            },
+            // A message in the chat got no answer: the chat is told why. The looper says this before
+            // it says the agent is idle.
+            failed(thread, { code, message }) {
                 const held = chats.get(thread);
-                if (status.state === "error" && held) {
-                    const { code, message } = status.detail;
-                    held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
-                    told(held);
-                }
-                if (atWork.size > 0 !== was)
-                    emit.status(stateNow());
+                if (!held)
+                    return;
+                held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
+                told(held);
             },
         },
         stopped: options.stopped,
@@ -267,8 +263,10 @@ export function createChats(options) {
     };
     return {
         /**
-         * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
-         * a turn running there takes it at its next model request.
+         * Say a message in a chat, or in a new chat it starts. A new chat's first message is put to
+         * the agent's main loop, which gives it to new work or to work in a turn; from then on the
+         * chat's messages are that work's: with no turn of it running one starts a turn, and a turn
+         * running takes it at its next model request.
          */
         async send({ chat, text }) {
             if (chat !== undefined) {
@@ -332,18 +330,18 @@ export function createChats(options) {
          */
         stop: () => looper.stop(),
         start: () => looper.start(),
-        /** Go on with the turns that were cut off when the agent last ran, each once. */
+        /** Go on with what was cut off when the agent last ran, each once: turns, and messages waiting. */
         async resume() {
             // The chats first: what a turn says moves its chat in the list.
             await load();
             await looper.resume();
         },
         /**
-         * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
-         * that opens this store next goes on with them.
+         * Close for good: its turns are cut, and none starts after. They stay marked, as do messages
+         * no work has taken, so the engine that opens this store next goes on with them.
          */
         close: () => looper.close(),
-        /** Settles when every chat's latest turn has written all it will. */
+        /** Settles when every piece of work's latest turn has written all it will. */
         async settled() {
             await loaded?.catch(() => undefined);
             await looper.settled();

package/dist/node_modules/assistant/dist/src/engine.js

@@ -68,7 +68,7 @@ export function startEngine(ctx, options) {
      * settings answer, and no tools slot is away. As the agent starts, what it is bound to may not
      * be running yet, so this is looked at again whenever that may have changed: a slot's provider
      * is back, a tools slot is made or gone, or one says its tools changed. A tools slot that stays
-     * away holds them back; a message in a chat starts that chat's turn anyway.
+     * away holds them back; a message in a chat starts a turn anyway.
      */
     let wentOn = false;
     /** Each tools slot heard for its tools changing, with how to stop hearing it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {