totemlayer 0.1.16 → 0.1.18

package/bin/mission-worker.mjs

@@ -21,7 +21,6 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { inspectLocalRepository } from "./repository.mjs";
 import { localClientEnvironment } from "./platform-client.mjs";
 import { localModelEndpoint } from "./local-model-provider.mjs";
-import { customerInspector } from "./local-inspector.mjs";
 import { externalModelReply, isExternalModelProvider } from "./model-adapter.mjs";
 import { runDockerNodeTests } from "./docker-test-sandbox.mjs";
 import { acquireMissionAgentSession, assertMissionAgentSession } from "./mission-agent-session.mjs";
@@ -753,10 +752,7 @@ export async function runCodexMissionAgent({
   stage,
   agentName,
   agentAddress,
-  inspector = customerInspector(),
-  task,
 }) {
-  await inspector.assertAllowed("input", prompt, { task, signal });
   if (provider !== "ollama-local")
     throw new Error(
       "The legacy Codex adapter requires explicit provider: ollama-local. Use runLocalMissionAgent for native Qwen by default.",
@@ -842,7 +838,6 @@ export async function runCodexMissionAgent({
       });
   }
   if (!final.trim()) throw new Error("The connected agent returned no final result.");
-  await inspector.assertAllowed("output", { text: final, commands }, { task, signal });
   return { text: final.slice(0, 32000), commands: commands.slice(-30) };
 }
 
@@ -909,14 +904,7 @@ export function redactRepositorySource(source) {
   return output;
 }
 
-export async function repositoryEvidence(
-  checkout,
-  stage,
-  checkoutInfo,
-  inspector = customerInspector(),
-  task,
-  signal,
-) {
+export async function repositoryEvidence(checkout, stage, checkoutInfo) {
   if (!["engineering", "review"].includes(stage)) return "";
   const tracked = (await git(checkout, "ls-files"))
     .split("\n")
@@ -947,9 +935,7 @@ export async function repositoryEvidence(
         throw new Error(`The reviewer cannot inspect the complete changed file: ${path}`);
       continue;
     }
-    const original = await readFile(absolute, "utf8");
-    await inspector.assertAllowed("tool-result", { path, source: original }, { task, signal });
-    const source = redactRepositorySource(original);
+    const source = redactRepositorySource(await readFile(absolute, "utf8"));
     const numbered = source
       .split("\n")
       .map((line, index) => `${index + 1}: ${line}`)
@@ -964,10 +950,7 @@ export async function repositoryEvidence(
   return JSON.stringify({ trackedFiles: paths, changedFiles: changed, files });
 }
 
-async function codeRepositoryEvidence(
-  checkout,
-  { repair = false, inspector = customerInspector(), task, signal } = {},
-) {
+async function codeRepositoryEvidence(checkout, { repair = false } = {}) {
   const checkoutPath = await realpath(checkout);
   const changed = repair
     ? [
@@ -1005,7 +988,6 @@ async function codeRepositoryEvidence(
       continue;
     }
     const content = await readFile(absolute, "utf8");
-    await inspector.assertAllowed("tool-result", { path, content }, { task, signal });
     if (
       /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk-[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16})\b/.test(
         content,
@@ -1587,10 +1569,7 @@ async function runStructuredMissionAgent({
   reasoning = false,
   rejectionEvidenceDirectory,
   adapterSettings = {},
-  inspector = customerInspector(),
-  task,
 }) {
-  await inspector.assertAllowed("input", prompt, { task, signal });
   const regressionFile =
     stage === "code" && !repair ? await selectMissionRegressionTestFile(checkout) : null;
   const properties =
@@ -1651,9 +1630,8 @@ async function runStructuredMissionAgent({
     throw new Error("Specify the installed model for this provider.");
   const evidence =
     stage === "code"
-      ? await codeRepositoryEvidence(checkout, { repair, inspector, task, signal })
-      : await repositoryEvidence(checkout, stage, checkoutInfo, inspector, task, signal);
-  await inspector.assertAllowed("tool-result", evidence, { task, signal });
+      ? await codeRepositoryEvidence(checkout, { repair })
+      : await repositoryEvidence(checkout, stage, checkoutInfo);
   const regressionInstruction = regressionFile
     ? `\n\nWorker-selected regression file: ${JSON.stringify(regressionFile.path)}. Return exactly this one path in testChanges, as a new file. Do not edit, replace, or rename any existing test file in initial generation. The new .test.js file uses ${regressionFile.moduleType === "module" ? "ES modules: import test from 'node:test' and assert from 'node:assert/strict'" : "CommonJS: require('node:test') and require('node:assert/strict'); use an async test with dynamic import() if the source API is an ES module"}. Import the actual source API with paths relative to this file. Node --test discovers this filename. Baseline expectation changes for accepted new fields are reserved for exact-edit repair after actual test failure.`
     : "";
@@ -1662,7 +1640,6 @@ async function runStructuredMissionAgent({
   let correction = "";
   const useReasoning = reasoning === true && ["code", "review"].includes(stage);
   for (let attempt = 0; attempt < (stage === "code" ? 2 : 1); attempt += 1) {
-    await inspector.assertAllowed("input", correction, { task, signal });
     const generationLimit = useReasoning ? 8192 : stage === "code" ? 4096 : 2048;
     const data = await requestModel(endpoint, {
       method: "POST",
@@ -1709,25 +1686,15 @@ async function runStructuredMissionAgent({
       provider !== "ollama-local" ? data?.choices?.[0]?.message?.content : data?.message?.content;
     if (typeof result !== "string" || !result.trim())
       throw new Error("The local model returned no structured result.");
-    await inspector.assertAllowed("output", result, { task, signal: combined });
     if (stage !== "code") return { text: result.slice(0, 32000), commands: [] };
     try {
       return repair
-        ? await inspector.runAction(
-            { checkout, result },
-            (input) => applyModelFileEdits(input.checkout, input.result),
-            { task, signal: combined },
-          )
-        : await inspector.runAction(
-            { checkout, result },
-            (input) =>
-              applyModelFileChanges(input.checkout, input.result, {
-                requireRegressionTests: true,
-                requireSeparateTestChanges: true,
-                newRegressionTestPath: regressionFile.path,
-              }),
-            { task, signal: combined },
-          );
+        ? await applyModelFileEdits(checkout, result)
+        : await applyModelFileChanges(checkout, result, {
+            requireRegressionTests: true,
+            requireSeparateTestChanges: true,
+            newRegressionTestPath: regressionFile.path,
+          });
     } catch (error) {
       if (rejectionEvidenceDirectory) {
         await mkdir(rejectionEvidenceDirectory, {
@@ -2419,7 +2386,6 @@ async function settleCompletedResult(client, missionId, workItemId, path, record
     stage: record.stage,
     result: record.result,
     leaseToken: record.leaseToken,
-    originalTask: record.originalTask,
   });
 }
 
@@ -2431,7 +2397,6 @@ async function recoverReadyCompletions(
   signal,
   emit,
   limit = Infinity,
-  inspector = customerInspector(),
 ) {
   let handled = 0;
   for (const name of await readdir(directory)) {
@@ -2479,7 +2444,6 @@ async function recoverReadyCompletions(
         await reportBlockedCompletion(record);
         continue;
       }
-      await inspector.assertAllowed("output", record.result, { task: record.originalTask, signal });
       if (record.state === "result_settling")
         await settleCompletedResult(client, missionId, workItemId, path, record, signal);
       await client.missions.complete(
@@ -2557,26 +2521,7 @@ export async function runMissionWorker({
   emit = () => {},
   runAgent = runLocalMissionAgent,
   adapterSettings = {},
-  inspector,
-  inspectorOptions,
 }) {
-  inspector = customerInspector({ inspector, inspectorOptions });
-  const uncheckedRunAgent = runAgent;
-  let originalTask;
-  runAgent = async (input) => {
-    const result = await inspector.runAction(
-      {
-        prompt: input.prompt,
-        checkout: input.checkout,
-        write: input.write ?? false,
-        stage: input.stage,
-      },
-      (snapshot) => uncheckedRunAgent({ ...input, ...snapshot, inspector, task: originalTask }),
-      { task: originalTask, signal: input.signal },
-    );
-    await inspector.assertAllowed("output", result, { task: originalTask, signal: input.signal });
-    return result;
-  };
   if (!UUID.test(missionId)) throw new Error("Provide a valid mission ID.");
   missionModelEndpoint(provider, { ollamaUrl, qwenUrl, nimUrl });
   model ??=
@@ -2655,7 +2600,6 @@ export async function runMissionWorker({
           signal,
           emit,
           _singleCycle ? 1 : Infinity,
-          inspector,
         );
         if (_singleCycle && recovered) return { activity: "recovery", handled: recovered };
         const reconciled = await recoverKnownLocalTestFailures(
@@ -2668,7 +2612,6 @@ export async function runMissionWorker({
         );
         if (_singleCycle && reconciled) return { activity: "recovery", handled: reconciled };
         const mission = await client.missions.get(missionId, { signal });
-        originalTask = String(mission.goal ?? "");
         if (
           mission.status === "canceled" ||
           mission.status === "completed" ||
@@ -2713,32 +2656,6 @@ export async function runMissionWorker({
           )
             continue;
           processed += 1;
-          try {
-            await inspector.assertAllowed(
-              "input",
-              {
-                goal: mission.goal,
-                desiredOutput: mission.desiredOutput,
-                repository: mission.repository,
-                workItem,
-                events: mission.events ?? [],
-                artifacts: mission.artifacts ?? [],
-              },
-              { task: originalTask, signal },
-            );
-          } catch (error) {
-            if (!error.code?.startsWith("INSPECTION_")) throw error;
-            if (!reportedAttention.has(workItem.id)) {
-              await recordRecoveryBlocker(workItem, error.code);
-              emit({
-                type: "needs_attention",
-                workItemId: workItem.id,
-                code: error.code,
-                message: "The customer-side inspector blocked this assignment before launch.",
-              });
-            }
-            continue;
-          }
           let stage;
           try {
             stage = stageOf(workItem);
@@ -3091,16 +3008,6 @@ export async function runMissionWorker({
                   ? ["repository.read"]
                   : [];
           const authorizeLocalLaunch = async () => {
-            await inspector.assertAllowed(
-              "action",
-              {
-                stage,
-                actions: repositoryActions,
-                resource: mission.repository?.url ?? null,
-                objective: workItem.objective,
-              },
-              { task: originalTask, signal: combined },
-            );
             // Renewal rechecks mission state, current credential, membership, and the lease.
             await client.missions.renew(missionId, workItem.id, claim.leaseToken, {
               signal: combined,
@@ -3149,15 +3056,6 @@ export async function runMissionWorker({
               for (const repositoryAction of repositoryActions) {
                 if (!mission.repository)
                   throw new Error("This assignment needs a selected repository.");
-                await inspector.assertAllowed(
-                  "action",
-                  {
-                    action: repositoryAction,
-                    resource: mission.repository.url,
-                    objective: workItem.objective,
-                  },
-                  { task: originalTask, signal: combined },
-                );
                 const reservation =
                   (prior?.reservedEffects ?? []).find(
                     (effect) =>
@@ -3199,16 +3097,6 @@ export async function runMissionWorker({
                   effectIds,
                 });
                 for (const effectId of effectIds) {
-                  await inspector.assertAllowed(
-                    "action",
-                    {
-                      effectId,
-                      actions: repositoryActions,
-                      resource: mission.repository.url,
-                      objective: workItem.objective,
-                    },
-                    { task: originalTask, signal: combined },
-                  );
                   const dispatch = await client.missions.dispatchEffect(
                     missionId,
                     effectId,
@@ -3548,7 +3436,6 @@ export async function runMissionWorker({
                   state: "result_settling",
                   stage,
                   result,
-                  originalTask,
                   leaseToken: claim.leaseToken,
                   effectIds: [...effectIds],
                   repositoryUrl: mission.repository.url,
@@ -3569,15 +3456,10 @@ export async function runMissionWorker({
                   state: "ready",
                   stage,
                   result,
-                  originalTask,
                   leaseToken: claim.leaseToken,
                 });
               }
             }
-            await inspector.assertAllowed("output", result, {
-              task: originalTask,
-              signal: combined,
-            });
             await client.missions.complete(
               missionId,
               workItem.id,

package/bin/model-adapter.mjs

@@ -7,11 +7,32 @@ import { installedClientInvocation, localClientEnvironment } from "./platform-cl
 import { WorkerError } from "./worker-core/errors.mjs";
 
 export function providerFailureCode(text) {
-  if (/unexpected argument|unknown option|unrecognized option|no such option|unknown flag/i.test(text)) return "AGENT_CLI_INCOMPATIBLE";
-  if (/not logged in|authentication required|invalid[_ ]api[_ ]key|unauthorized|refresh token.*(?:expired|reused)|sign in.*required/i.test(text)) return "AGENT_AUTH_REQUIRED";
-  if (/usage limit|rate limit|quota.*(?:exceeded|insufficient)|insufficient_quota|credit balance/i.test(text)) return "AGENT_QUOTA_EXCEEDED";
-  if (/sandbox.*(?:setup failed|not available|not configured|unsupported|error)|CreateProcessAsUser|error 1385/i.test(text)) return "AGENT_SANDBOX_UNAVAILABLE";
-  if (/model.*(?:not found|not supported|does not exist|not have access)|model_not_found/i.test(text)) return "AGENT_MODEL_UNAVAILABLE";
+  if (
+    /unexpected argument|unknown option|unrecognized option|no such option|unknown flag/i.test(text)
+  )
+    return "AGENT_CLI_INCOMPATIBLE";
+  if (
+    /not logged in|authentication required|invalid[_ ]api[_ ]key|unauthorized|refresh token.*(?:expired|reused)|sign in.*required/i.test(
+      text,
+    )
+  )
+    return "AGENT_AUTH_REQUIRED";
+  if (
+    /usage limit|rate limit|quota.*(?:exceeded|insufficient)|insufficient_quota|credit balance/i.test(
+      text,
+    )
+  )
+    return "AGENT_QUOTA_EXCEEDED";
+  if (
+    /sandbox.*(?:setup failed|not available|not configured|unsupported|error)|CreateProcessAsUser|error 1385/i.test(
+      text,
+    )
+  )
+    return "AGENT_SANDBOX_UNAVAILABLE";
+  if (
+    /model.*(?:not found|not supported|does not exist|not have access)|model_not_found/i.test(text)
+  )
+    return "AGENT_MODEL_UNAVAILABLE";
   return "AGENT_EXIT_FAILED";
 }
 
@@ -123,7 +144,8 @@ export async function externalModelReply({
       ];
       parseResult = (output) => {
         const result = JSON.parse(output);
-        if (result.is_error || result.subtype !== "success") throw new WorkerError(providerFailureCode(String(result.result ?? "")));
+        if (result.is_error || result.subtype !== "success")
+          throw new WorkerError(providerFailureCode(String(result.result ?? "")));
         return {
           status: "completed",
           output: result.structured_output

package/bin/network-retry.mjs

@@ -0,0 +1,26 @@
+import { pause } from "./network.mjs";
+
+export function transientNetworkError(error) {
+  return (
+    error?.status === 429 ||
+    error?.status >= 500 ||
+    ["NETWORK_BUSY", "NETWORK_ERROR", "TIMEOUT"].includes(error?.code)
+  );
+}
+
+// Only use for reads or mutations protected by a durable idempotency key.
+export async function retryNetwork(
+  operation,
+  { signal, onRetry = () => {}, delayMs = 1000, attempts = 4 } = {},
+) {
+  for (let attempt = 0; ; attempt++) {
+    signal?.throwIfAborted();
+    try {
+      return await operation();
+    } catch (error) {
+      if (signal?.aborted || !transientNetworkError(error) || attempt + 1 >= attempts) throw error;
+      onRetry(error);
+      await pause(Math.min(delayMs * 2 ** attempt, 10000), signal);
+    }
+  }
+}

package/bin/network-runtime.mjs

@@ -5,6 +5,7 @@ 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 {
@@ -406,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);
@@ -575,10 +591,15 @@ export async function runRuntime(settings) {
   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 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 } : {}) };
+    diagnostics = {
+      phase: "blocked",
+      errorCode: runtimeErrorCode(error),
+      ...(typeof context.messageId === "string" ? { messageId: context.messageId } : {}),
+    };
     if (settings.once) process.exitCode = 1;
     emit({
       type: "runtime_error",
@@ -599,9 +620,21 @@ export async function runRuntime(settings) {
   try {
     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" } } : {}) },
+        {
+          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;
@@ -642,6 +675,7 @@ 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 }),
@@ -720,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",
@@ -737,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;
@@ -745,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/runtime-diagnostics.mjs

@@ -1,12 +1,37 @@
 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",
+  "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 };