totemlayer 0.1.15 → 0.1.17

package/bin/network-runtime.mjs

@@ -5,7 +5,9 @@ import { join } from "node:path";
 import { pause } from "./network.mjs";
 import { localModelEndpoint } from "./local-model-provider.mjs";
 import { runInboxQueue } from "./inbox-queue.mjs";
+import { retryNetwork, transientNetworkError } from "./network-retry.mjs";
 import { customerInspector, inspectNetworkMessage } from "./local-inspector.mjs";
+import { runtimeErrorCode } from "./runtime-diagnostics.mjs";
 import {
   externalModelReply,
   isExternalModelProvider,
@@ -405,23 +407,38 @@ async function generate({
             new Error(
               "A previous provider turn has an uncertain outcome. Inspect its private journal before retrying.",
             ),
-            { code: "AGENT_OUTCOME_UNCERTAIN" },
+            {
+              code: state.externalFailure ?? "AGENT_OUTCOME_UNCERTAIN",
+              externalOutcomeUncertain: true,
+            },
           );
         state.externalPending = true;
         await journal.save(key, state);
       }
-      const response = await modelReply({
-        origin: settings.origin,
-        provider: settings.provider,
-        qwenUrl: settings.qwenUrl,
-        nimUrl: settings.nimUrl,
-        model: settings.model,
-        messages: state.messages,
-        tools,
-        signal,
-        timeoutMs: settings.modelTimeoutMs,
-        adapterSettings: settings.adapterSettings,
-      });
+      let response;
+      try {
+        response = await modelReply({
+          origin: settings.origin,
+          provider: settings.provider,
+          qwenUrl: settings.qwenUrl,
+          nimUrl: settings.nimUrl,
+          model: settings.model,
+          messages: state.messages,
+          tools,
+          signal,
+          timeoutMs: settings.modelTimeoutMs,
+          adapterSettings: settings.adapterSettings,
+        });
+      } catch (error) {
+        // Preserve a fixed diagnostic instead of hiding the original failure after restart.
+        // Keep externalPending: arbitrary external providers may have uncertain side effects.
+        if (isExternalModelProvider(settings.provider)) {
+          error.externalOutcomeUncertain = true;
+          state.externalFailure = runtimeErrorCode(error);
+          await journal.save(key, state);
+        }
+        throw error;
+      }
       await settings.inspector.assertAllowed("output", response, { task: text, signal });
       delete state.externalPending;
       state.messages.push(response);
@@ -572,7 +589,17 @@ export async function runRuntime(settings) {
   let inbox;
   let humanDone = false;
   let fatalError;
+  let diagnosticsSupported = false;
+  let diagnostics = { phase: "starting" };
+  const packageVersion = JSON.parse(
+    await readFile(new URL("../package.json", import.meta.url), "utf8"),
+  ).version;
   const report = (error, context = {}) => {
+    diagnostics = {
+      phase: "blocked",
+      errorCode: runtimeErrorCode(error),
+      ...(typeof context.messageId === "string" ? { messageId: context.messageId } : {}),
+    };
     if (settings.once) process.exitCode = 1;
     emit({
       type: "runtime_error",
@@ -591,11 +618,28 @@ export async function runRuntime(settings) {
     });
   };
   try {
-    const beat = async () =>
-      client.runtime.heartbeat(
-        { label: `${settings.provider}:${settings.model}`.slice(0, 100) },
+    const beat = async () => {
+      const result = await client.runtime.heartbeat(
+        {
+          label: `${settings.provider}:${settings.model}`.slice(0, 100),
+          ...(diagnosticsSupported
+            ? {
+                diagnostics: {
+                  ...diagnostics,
+                  packageVersion,
+                  provider: settings.provider,
+                  platform: ["darwin", "linux", "win32"].includes(process.platform)
+                    ? process.platform
+                    : "other",
+                },
+              }
+            : {}),
+        },
         { signal },
       );
+      diagnosticsSupported = result?.diagnosticsSupported === true;
+      return result;
+    };
     await beat();
     heartbeat = (async () => {
       while (!signal.aborted) {
@@ -623,6 +667,7 @@ export async function runRuntime(settings) {
         inspection: settings.inspector.mode,
       },
     });
+    diagnostics = { phase: "waiting" };
     // 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 = runInboxQueue({
@@ -630,16 +675,21 @@ export async function runRuntime(settings) {
       pollMs: settings.pollMs,
       concurrency: settings.messageConcurrency ?? 2,
       once: settings.once,
+      onPollError: (error) => report(error),
       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 {
+          diagnostics = { phase: "working", messageId: message.id };
+          emit({ type: "message_started", data: { messageId: message.id } });
           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 });
+            diagnostics = { phase: "waiting" };
+            emit({ type: "message_handled", data: { messageId: message.id } });
             return;
           }
           const thread = [];
@@ -696,6 +746,7 @@ export async function runRuntime(settings) {
             { signal },
           );
           await client.messages.ack(message.id, { signal });
+          diagnostics = { phase: "waiting" };
           emit({
             type: "message_handled",
             data: { messageId: message.id, conversationId: message.conversationId },
@@ -703,10 +754,12 @@ export async function runRuntime(settings) {
         } 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;
+          // Retry this durable message on the next poll without stopping other turns.
+          if (transientNetworkError(error)) return;
           if (
             (error.status >= 400 && error.status < 500) ||
-            error.code === "AGENT_OUTCOME_UNCERTAIN"
+            error.code === "AGENT_OUTCOME_UNCERTAIN" ||
+            error.externalOutcomeUncertain
           )
             await journal.save(`message-blocker:${message.id}`, {
               code: error.code ?? "MESSAGE_BLOCKED",
@@ -720,7 +773,20 @@ export async function runRuntime(settings) {
       }
     });
     do {
-      const commands = await client.chatCommands.list({ limit: 20 }, { signal });
+      let commands;
+      try {
+        commands = await retryNetwork(() => client.chatCommands.list({ limit: 20 }, { signal }), {
+          signal,
+          delayMs: settings.pollMs,
+          onRetry: report,
+        });
+      } catch (error) {
+        if (signal.aborted) break;
+        if (!transientNetworkError(error)) throw error;
+        report(error);
+        await pause(Math.max(settings.pollMs, 100), signal);
+        continue;
+      }
       for (const command of commands.data) {
         if (signal.aborted) break;
         let claim;
@@ -728,6 +794,10 @@ export async function runRuntime(settings) {
           claim = await client.chatCommands.claim(command.id, { signal });
         } catch (error) {
           if (error.status === 409) continue;
+          if (transientNetworkError(error)) {
+            report(error);
+            continue;
+          }
           throw error;
         }
         const leaseStop = new AbortController();

package/bin/platform-client.mjs

@@ -1,4 +1,5 @@
-import { join } from "node:path";
+import { join, dirname, isAbsolute, extname } from "node:path";
+import { existsSync } from "node:fs";
 
 const INHERITED_ENVIRONMENT = new Set(
   [
@@ -71,9 +72,36 @@ export function powershellInvocation(script, environment = process.env) {
 // base64-encoded JSON argument array is interpolated into the script, so a
 // Windows path can never become shell syntax.
 export function installedClientInvocation(command, args, environment = process.env) {
+  // Native executables inherit the pipe directly. For npm clients, launch the
+  // installed JavaScript entrypoint with Node rather than a .cmd/PowerShell
+  // pipeline, which can leave stdin open indefinitely on Windows.
+  const clientPackage = {
+    codex: ["@openai", "codex", "bin", "codex.js"],
+    claude: ["@anthropic-ai", "claude-code", "cli.js"],
+  }[command];
+  const pathValue =
+    environment.PATH ??
+    environment.Path ??
+    Object.entries(environment).find(([key]) => key.toUpperCase() === "PATH")?.[1] ??
+    "";
+  const candidates = isAbsolute(command)
+    ? [command]
+    : pathValue
+        .split(";")
+        .filter(Boolean)
+        .flatMap((dir) => [join(dir, `${command}.exe`), join(dir, `${command}.cmd`)]);
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    if (extname(path).toLowerCase() === ".exe") return { command: path, args };
+    if (clientPackage) {
+      const entry = join(dirname(path), "node_modules", ...clientPackage);
+      if (existsSync(entry)) return { command: process.execPath, args: [entry, ...args] };
+    }
+    break;
+  }
   const payload = Buffer.from(JSON.stringify([command, ...args]), "utf8").toString("base64");
   return powershellInvocation(
-    `$ErrorActionPreference = 'Stop'\n$items = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}')) | ConvertFrom-Json\n$client = [string]$items[0]\n$clientArgs = @($items | Select-Object -Skip 1)\n& $client @clientArgs\nif ($null -eq $LASTEXITCODE) { exit 1 }\nexit $LASTEXITCODE`,
+    `$ErrorActionPreference = 'Stop'\n$items = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}')) | ConvertFrom-Json\n$client = [string]$items[0]\n$clientArgs = @($items | Select-Object -Skip 1)\n$OutputEncoding = [Text.UTF8Encoding]::new($false)\n[Console]::OutputEncoding = $OutputEncoding\n$prompt = [Console]::In.ReadToEnd()\n$prompt | & $client @clientArgs\nif ($null -eq $LASTEXITCODE) { exit 1 }\nexit $LASTEXITCODE`,
     environment,
   );
 }

package/bin/runtime-diagnostics.mjs

@@ -0,0 +1,38 @@
+export const RUNTIME_ERROR_CODES = new Set([
+  "AGENT_START_FAILED",
+  "AGENT_EXIT_FAILED",
+  "AGENT_REPORTED_FAILURE",
+  "INVALID_AGENT_RESULT",
+  "AGENT_CLI_INCOMPATIBLE",
+  "AGENT_AUTH_REQUIRED",
+  "AGENT_QUOTA_EXCEEDED",
+  "AGENT_SANDBOX_UNAVAILABLE",
+  "AGENT_MODEL_UNAVAILABLE",
+  "AGENT_OUTCOME_UNCERTAIN",
+  "RUN_TIMEOUT",
+  "RUN_CANCELLED",
+  "OUTPUT_LIMIT_EXCEEDED",
+  "UNKNOWN_HTTP_OUTCOME",
+  "HTTP_AGENT_FAILED",
+  "INVALID_ADAPTER_CONFIG",
+  "INVALID_ADAPTER_ENV",
+  "INSPECTION_BLOCKED",
+  "INSPECTION_UNAVAILABLE",
+  "INSPECTION_UNSUPPORTED_FILE",
+  "AGENT_REPLY_TIMEOUT",
+  "INVALID_ASK",
+  "TOOL_NOT_ALLOWED",
+  "INVALID_PEER_REPLY",
+  "NETWORK_BUSY",
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "CANCELED",
+  "INVALID_NETWORK_CREDENTIAL",
+  "AGENT_IDENTITY_MISMATCH",
+  "MODEL_ERROR",
+  "MAX_STEPS",
+  "INTERNAL_ERROR",
+]);
+export function runtimeErrorCode(error) {
+  return RUNTIME_ERROR_CODES.has(error?.code) ? error.code : "INTERNAL_ERROR";
+}

package/bin/sdk/index.js

@@ -1,5 +1,4 @@
 import { TotemError } from "./errors.js";
-import { createLocalInspector, InspectionError } from "./inspector.js";
 import { idempotencyKey, sleep, Transport } from "./transport.js";
 import { assertInputFields, assistantCheckOptions, signalOnlyOptions } from "./request-options.js";
 export * from "./types.js";
@@ -113,11 +112,6 @@ export class Totem {
             },
             idempotencyKey: options.idempotencyKey ?? `sdk:reply:${id}`,
         })).data,
-        replyContent: async (id, content, options = {}) => (await this.#transport.request("POST", `/messages/${encodeURIComponent(id)}/reply`, {
-            ...options,
-            body: { content },
-            idempotencyKey: options.idempotencyKey ?? idempotencyKey(),
-        })).data,
         ack: async (id, options) => (await this.#transport.request("POST", `/messages/${encodeURIComponent(id)}/ack`, {
             ...options,
             body: {},
@@ -323,8 +317,6 @@ export class ConnectedAgent {
         if (!Number.isFinite(interval) || interval < 10)
             throw new TotemError("pollIntervalMs must be at least 10.", { code: "INVALID_CONFIG" });
         const controller = new AbortController();
-        const inspector = options.inspector ?? createLocalInspector();
-        const blocked = new Set();
         const report = (cause) => {
             this.#lastError = cause instanceof Error ? cause : new Error(String(cause));
             try {
@@ -340,42 +332,22 @@ export class ConnectedAgent {
                     for await (const message of this.client.messages.iterate({ direction: "inbound", unread: true, limit: 100 }, { signal: controller.signal })) {
                         if (controller.signal.aborted)
                             break;
-                        if (blocked.has(message.id))
-                            continue;
+                        const incoming = {
+                            ...message,
+                            text: message.content.type === "text"
+                                ? message.content.text
+                                : JSON.stringify(message.content.data),
+                            reply: (text, writeOptions = {}) => this.client.messages.reply(message.id, text, {
+                                ...writeOptions,
+                                idempotencyKey: writeOptions.idempotencyKey ?? `reply:${message.id}:0`,
+                            }),
+                            ack: () => this.client.messages.ack(message.id),
+                        };
                         try {
-                            if (message.content.type === "encrypted")
-                                throw new TotemError("Use E2eeTotem and pinned endpoint keys to process encrypted messages.", { code: "E2EE_CLIENT_REQUIRED" });
-                            await inspector.assertAllowed("input", { content: message.content, metadata: message.metadata ?? {} }, { signal: controller.signal });
-                            const files = message.attachments ?? [];
-                            const ids = new Set(files.map((file) => file.id));
-                            if (message.content.type === "text" &&
-                                message.content.attachments?.some((id) => !ids.has(id)))
-                                throw new InspectionError("INSPECTION_UNSUPPORTED_FILE");
-                            for (const file of files) {
-                                const downloaded = await this.client.attachments.download(file.id, {
-                                    signal: controller.signal,
-                                });
-                                await inspector.inspectFile(file.name, file.mediaType, downloaded.bytes, {
-                                    signal: controller.signal,
-                                });
-                            }
-                            const incoming = {
-                                ...message,
-                                text: message.content.type === "text"
-                                    ? message.content.text
-                                    : JSON.stringify(message.content.data),
-                                reply: (text, writeOptions = {}) => inspector.runAction({ id: message.id, text }, (input) => this.client.messages.reply(input.id, input.text, {
-                                    ...writeOptions,
-                                    idempotencyKey: writeOptions.idempotencyKey ?? `reply:${message.id}:0`,
-                                }), { signal: controller.signal }),
-                                ack: () => this.client.messages.ack(message.id),
-                            };
                             await handler(incoming);
                             await incoming.ack();
                         }
                         catch (error) {
-                            if (error instanceof InspectionError && error.code !== "INSPECTION_UNAVAILABLE")
-                                blocked.add(message.id);
                             report(error);
                         }
                     }
@@ -413,4 +385,3 @@ export class ConnectedAgent {
 /** Compatibility name for callers who prefer `new TotemAgent({ address, apiKey })`. */
 export class TotemAgent extends Totem {
 }
-export { createLocalInspector, InspectionError };

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.15";
+const CLI_VERSION = "0.1.13";
 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/bin/worker-core/adapters.mjs

@@ -51,7 +51,8 @@ export function createCommandAdapter(config) {
     !Array.isArray(config.args ?? []) ||
     !(config.args ?? []).every((arg) => typeof arg === "string" && !arg.includes("\0")) ||
     typeof config.cwd !== "string" ||
-    !isAbsolute(config.cwd)
+    !isAbsolute(config.cwd) ||
+    (config.classifyFailure !== undefined && typeof config.classifyFailure !== "function")
   ) {
     throw new WorkerError("INVALID_ADAPTER_CONFIG");
   }
@@ -76,13 +77,25 @@ export function createCommandAdapter(config) {
         let child;
         let failure;
         let output = "";
+        let diagnosticOutput = "";
         let bytes = 0;
         let killTimer;
         // Also remove surviving descendants if the parent exits before escalation.
         const kill = (kind) => {
           try {
             if (process.platform !== "win32" && child?.pid) process.kill(-child.pid, kind);
-            else child?.kill(kind);
+            else if (child?.pid) {
+              // A Windows shim can outlive its parent and keep stdio open.
+              const killer = spawn("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], {
+                windowsHide: true,
+                stdio: "ignore",
+              });
+              killer.on("error", () => {
+                try {
+                  child.kill(kind);
+                } catch {}
+              });
+            }
           } catch {
             /* The process may already have exited. */
           }
@@ -122,6 +135,7 @@ export function createCommandAdapter(config) {
         child.stderr.on("data", (chunk) => {
           bytes += chunk.length;
           if (bytes > maxOutputBytes) stop("OUTPUT_LIMIT_EXCEEDED");
+          else if (config.classifyFailure) diagnosticOutput += chunk.toString("utf8");
         });
         child.stdin.on("error", () => {
           /* A failed child can close stdin early. */
@@ -137,7 +151,15 @@ export function createCommandAdapter(config) {
             kill("SIGKILL");
             return reject(failure);
           }
-          if (code !== 0) return reject(new WorkerError("AGENT_EXIT_FAILED"));
+          if (code !== 0) {
+            try {
+              return reject(
+                new WorkerError(config.classifyFailure?.(diagnosticOutput) ?? "AGENT_EXIT_FAILED"),
+              );
+            } catch {
+              return reject(new WorkerError("AGENT_EXIT_FAILED"));
+            }
+          }
           try {
             resolve(validateResult(parseResult(output)));
           } catch (error) {

package/bin/worker-core/errors.mjs

@@ -1,8 +1,4 @@
 const SAFE_CODES = new Set([
-  "INSPECTION_BLOCKED",
-  "INSPECTION_UNAVAILABLE",
-  "INSPECTION_LIMIT",
-  "INSPECTION_UNSUPPORTED_FILE",
   "INTERNAL_ERROR",
   "INVALID_AGENT_RESULT",
   "INVALID_ADAPTER_ENV",
@@ -30,6 +26,11 @@ const SAFE_CODES = new Set([
   "INVALID_PROMPT",
   "AGENT_START_FAILED",
   "AGENT_EXIT_FAILED",
+  "AGENT_CLI_INCOMPATIBLE",
+  "AGENT_AUTH_REQUIRED",
+  "AGENT_QUOTA_EXCEEDED",
+  "AGENT_SANDBOX_UNAVAILABLE",
+  "AGENT_MODEL_UNAVAILABLE",
   "AGENT_REPORTED_FAILURE",
   "UNKNOWN_HTTP_OUTCOME",
   "HTTP_AGENT_FAILED",

package/package.json

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

package/scripts/prepare.mjs

@@ -0,0 +1,20 @@
+import { execFileSync } from "node:child_process";
+import { mkdir, readdir, copyFile } 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 });
+for (const name of await readdir(new URL("../../sdk/dist/", import.meta.url))) {
+  if (name.endsWith(".js"))
+    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));