totemlayer 0.1.14 → 0.1.15

package/bin/inbox-queue.mjs

@@ -0,0 +1,71 @@
+import { setTimeout as sleep } from "node:timers/promises";
+
+// Polling is independent of generation. Unrelated conversations can make
+// progress while one provider turn is slow; one conversation stays ordered.
+export async function runInboxQueue({
+  messages,
+  handle,
+  eligible = async () => true,
+  signal: ownerSignal,
+  pollMs,
+  concurrency = 2,
+  shouldContinue = () => true,
+  once = false,
+}) {
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 4)
+    throw new Error("Inbox concurrency must be between one and four.");
+  const stop = new AbortController();
+  const signal = AbortSignal.any([ownerSignal, stop.signal]);
+  const active = new Map();
+  const conversations = new Set();
+  const attempted = new Set();
+  let failure;
+  let pendingCount = 0;
+  try {
+    do {
+      const oldest = new Map();
+      for await (const message of messages(signal)) {
+        if (signal.aborted) break;
+        if (
+          active.has(message.id) ||
+          conversations.has(message.conversationId) ||
+          attempted.has(message.id)
+        )
+          continue;
+        if (!(await eligible(message))) continue;
+        // The server yields oldest first. Preserve that order within a chat.
+        if (!oldest.has(message.conversationId)) oldest.set(message.conversationId, message);
+      }
+      const pending = [...oldest.values()];
+      // Give both the backlog and recent conversations a slot, rather than
+      // draining yesterday's entire backlog before looking at today's inbox.
+      let recent = false;
+      while (pending.length && active.size < concurrency && !signal.aborted) {
+        const message = recent ? pending.pop() : pending.shift();
+        recent = !recent;
+        if (once) attempted.add(message.id);
+        conversations.add(message.conversationId);
+        const turn = Promise.resolve()
+          .then(() => handle(message, signal))
+          .catch((error) => {
+            failure ??= error;
+            stop.abort();
+          })
+          .finally(() => {
+            active.delete(message.id);
+            conversations.delete(message.conversationId);
+          });
+        active.set(message.id, turn);
+      }
+      pendingCount = pending.length;
+      if (!signal.aborted && (shouldContinue() || active.size || pendingCount))
+        await sleep(pollMs, undefined, { signal }).catch((error) => {
+          if (!signal.aborted) throw error;
+        });
+    } while (!signal.aborted && (shouldContinue() || active.size || pendingCount));
+  } finally {
+    stop.abort();
+    await Promise.allSettled(active.values());
+  }
+  if (failure) throw failure;
+}

package/bin/network-runtime.mjs

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { pause } from "./network.mjs";
 import { localModelEndpoint } from "./local-model-provider.mjs";
+import { runInboxQueue } from "./inbox-queue.mjs";
 import { customerInspector, inspectNetworkMessage } from "./local-inspector.mjs";
 import {
   externalModelReply,
@@ -624,88 +625,95 @@ export async function runRuntime(settings) {
     });
     // The A2A queue must keep moving while a human command waits on another agent.
     // ask_agent reads durable conversation history, so acknowledgments cannot steal a reply.
-    inbox = (async () => {
-      do {
-        for await (const message of client.messages.iterate(
-          { direction: "inbound", unread: true, limit: 100 },
-          { signal },
-        )) {
-          if (signal.aborted) break;
-          if (await journal.read(`message-blocker:${message.id}`)) continue;
-          try {
-            await inspectNetworkMessage(settings.inspector, client, message, { signal });
-            const continuation = autonomousReplyMetadata(message, settings, identity.address);
-            if (message.inReplyToId && !continuation) {
-              await client.messages.ack(message.id, { signal });
-              continue;
-            }
-            const thread = [];
-            let cursor;
-            for (let page = 0; page < 5; page++) {
-              const result = await client.conversations.messages(
-                message.conversationId,
-                { limit: 100, ...(cursor ? { cursor } : {}) },
-                { signal },
-              );
-              thread.push(...result.data);
-              if (thread.some((item) => item.id === message.id) || !result.nextCursor) break;
-              cursor = result.nextCursor;
-            }
-            for (const item of thread)
-              await inspectNetworkMessage(settings.inspector, client, item, { signal });
-            const history = boundedHistory(
-              thread.map((item) => ({
-                id: item.id,
-                actor: item.from === identity.address ? "agent" : "human",
-                text:
-                  item.content.type === "text"
-                    ? item.content.text
-                    : JSON.stringify(item.content.data),
-              })),
-              message.id,
-            );
-            const text = await generate({
-              client,
-              identity,
-              journal,
-              key: `message:${message.id}`,
-              text:
-                message.content.type === "text"
-                  ? message.content.text
-                  : JSON.stringify(message.content.data),
-              history,
-              settings,
-              signal,
-              allowTools: false,
-            });
-            await settings.inspector.runAction(
-              { id: message.id, text },
-              (inspected) =>
-                client.messages.reply(inspected.id, inspected.text, {
-                  idempotencyKey: operationKey(identity.id, "reply", message.id),
-                  ...(continuation ? { metadata: continuation } : {}),
-                  signal,
-                }),
+    inbox = runInboxQueue({
+      signal,
+      pollMs: settings.pollMs,
+      concurrency: settings.messageConcurrency ?? 2,
+      once: settings.once,
+      shouldContinue: () => !settings.once || !humanDone,
+      messages: (signal) =>
+        client.messages.iterate({ direction: "inbound", unread: true, limit: 100 }, { signal }),
+      eligible: async (message) => !(await journal.read(`message-blocker:${message.id}`)),
+      handle: async (message, signal) => {
+        try {
+          await inspectNetworkMessage(settings.inspector, client, message, { signal });
+          const continuation = autonomousReplyMetadata(message, settings, identity.address);
+          if (message.inReplyToId && !continuation) {
+            await client.messages.ack(message.id, { signal });
+            return;
+          }
+          const thread = [];
+          let cursor;
+          for (let page = 0; page < 5; page++) {
+            const result = await client.conversations.messages(
+              message.conversationId,
+              { limit: 100, ...(cursor ? { cursor } : {}) },
               { signal },
             );
-            await client.messages.ack(message.id, { signal });
-            emit({
-              type: "message_handled",
-              data: { messageId: message.id, conversationId: message.conversationId },
-            });
-          } catch (error) {
-            if (!signal.aborted) report(error, { messageId: message.id });
-            if (error.status === 401) throw error;
-            if (error.status === 429 || error.status >= 500) throw error;
-            if (error.status >= 400 && error.status < 500)
-              await journal.save(`message-blocker:${message.id}`, {
-                code: error.code ?? "MESSAGE_BLOCKED",
-              });
+            thread.push(...result.data);
+            if (thread.some((item) => item.id === message.id) || !result.nextCursor) break;
+            cursor = result.nextCursor;
           }
+          for (const item of thread)
+            await inspectNetworkMessage(settings.inspector, client, item, { signal });
+          const history = boundedHistory(
+            thread.map((item) => ({
+              id: item.id,
+              actor: item.from === identity.address ? "agent" : "human",
+              text:
+                item.content.type === "text"
+                  ? item.content.text
+                  : JSON.stringify(item.content.data),
+            })),
+            message.id,
+          );
+          const text = await generate({
+            client,
+            identity,
+            journal,
+            key: `message:${message.id}`,
+            text:
+              message.content.type === "text"
+                ? message.content.text
+                : JSON.stringify(message.content.data),
+            history,
+            settings: {
+              ...settings,
+              modelTimeoutMs:
+                settings.messageTimeoutMs ?? Math.min(settings.modelTimeoutMs ?? 900000, 120000),
+            },
+            signal,
+            allowTools: false,
+          });
+          await settings.inspector.runAction(
+            { id: message.id, text },
+            (inspected) =>
+              client.messages.reply(inspected.id, inspected.text, {
+                idempotencyKey: operationKey(identity.id, "reply", message.id),
+                ...(continuation ? { metadata: continuation } : {}),
+                signal,
+              }),
+            { signal },
+          );
+          await client.messages.ack(message.id, { signal });
+          emit({
+            type: "message_handled",
+            data: { messageId: message.id, conversationId: message.conversationId },
+          });
+        } catch (error) {
+          if (!signal.aborted) report(error, { messageId: message.id });
+          if (error.status === 401) throw error;
+          if (error.status === 429 || error.status >= 500) throw error;
+          if (
+            (error.status >= 400 && error.status < 500) ||
+            error.code === "AGENT_OUTCOME_UNCERTAIN"
+          )
+            await journal.save(`message-blocker:${message.id}`, {
+              code: error.code ?? "MESSAGE_BLOCKED",
+            });
         }
-        if (!signal.aborted && (!settings.once || !humanDone)) await pause(settings.pollMs, signal);
-      } while (!signal.aborted && (!settings.once || !humanDone));
-    })().catch((error) => {
+      },
+    }).catch((error) => {
       if (!signal.aborted) {
         fatalError = error;
         shutdown.abort();

package/bin/totem.mjs

@@ -4,7 +4,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stripVTControlCharacters } from "node:util";
 
-const CLI_VERSION = "0.1.14";
+const CLI_VERSION = "0.1.15";
 const DEFAULT_BASE_URL = "https://totemlayer.com";
 const API_KEY_PATTERN = /^at_(?:live|test)_[A-Za-z0-9_-]{20,}$/;
 const ACTION_PATTERN = /^[a-z0-9][a-z0-9._:-]*$/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Cross-platform CLI for TotemLayer agent identity and authorization",
   "type": "module",
   "bin": {

package/scripts/prepare.mjs

@@ -1,24 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdir, readdir, copyFile, rm } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-
-// Build from the sibling source every time a distributable is packed.
-const sdk = fileURLToPath(new URL("../../sdk/", import.meta.url));
-const destination = new URL("../bin/sdk/", import.meta.url);
-execFileSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build", "--prefix", sdk], {
-  stdio: "inherit",
-});
-await mkdir(destination, { recursive: true });
-// The CLI has no encrypted endpoint/key-store configuration yet. Keep the optional
-// HPKE entrypoints in the separately installed SDK, not a client without that dependency.
-const encryptedOnly = new Set(["e2ee-wire.js", "e2ee.js", "encrypted-client.js", "encrypted.js"]);
-for (const name of encryptedOnly) await rm(new URL(name, destination), { force: true });
-for (const name of await readdir(new URL("../../sdk/dist/", import.meta.url))) {
-  if (name.endsWith(".js") && !encryptedOnly.has(name))
-    await copyFile(new URL(`../../sdk/dist/${name}`, import.meta.url), new URL(name, destination));
-}
-
-const workerCore = new URL("../bin/worker-core/", import.meta.url);
-await mkdir(workerCore, { recursive: true });
-for (const name of ["adapters.mjs", "errors.mjs"])
-  await copyFile(new URL(`../../agent-worker/${name}`, import.meta.url), new URL(name, workerCore));