@amaster.ai/employee-runtime-connector 0.1.1-beta.255 → 0.1.1-beta.256

package/dist/amaster-runtime-daemon.mjs

@@ -5508,6 +5508,32 @@ var amasterRuntimeConnectorLogIngestSchema = external_exports.object({
   message: external_exports.string().max(16e3),
   payload: external_exports.record(external_exports.unknown()).default({})
 });
+var AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_ENTRIES = 32;
+var AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES = 128 * 1024;
+var amasterRuntimeConnectorLogIngestBatchSchema = external_exports.object({
+  entries: external_exports.array(amasterRuntimeConnectorLogIngestSchema).min(1).max(AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_ENTRIES)
+}).superRefine((value, ctx) => {
+  const commandIds = new Set(value.entries.flatMap((entry) => entry.commandId ? [entry.commandId] : []));
+  if (commandIds.size > 1) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["entries"],
+      message: "Runtime connector log batch entries must share one commandId"
+    });
+  }
+  const serializedBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  if (serializedBytes > AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.too_big,
+      type: "array",
+      maximum: AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES,
+      inclusive: true,
+      exact: false,
+      path: ["entries"],
+      message: "Runtime connector log batch exceeds 128 KiB"
+    });
+  }
+});
 var amasterRuntimeConnectorCostIngestSchema = external_exports.object({
   commandId: external_exports.string().uuid(),
   idempotencyKey: external_exports.string().trim().regex(/^runtime-command-cost:[0-9a-f-]{36}$/i).optional(),
@@ -33516,7 +33542,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.255";
+var CONNECTOR_VERSION = "0.1.1-beta.256";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire2(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -35645,6 +35671,25 @@ function redactProtectedText(value, protectedValues = []) {
   }
   return text3;
 }
+var RUNTIME_LOG_BATCH_MAX_ENTRIES = 32;
+var RUNTIME_LOG_BATCH_MAX_BYTES = 128 * 1024;
+var RUNTIME_LOG_BATCH_FLUSH_MS = 250;
+function runtimeLogBatchEntries(command, entries) {
+  return entries.map((entry) => ({
+    commandId: command.commandId,
+    runId: commandRunId(command) ?? void 0,
+    stream: entry.stream,
+    level: entry.level,
+    message: truncateText(entry.message),
+    payload: entry.payload ?? {}
+  }));
+}
+function runtimeLogBatchEntryBytes(command, entry) {
+  return Buffer.byteLength(JSON.stringify(runtimeLogBatchEntries(command, [entry])[0]));
+}
+function runtimeLogBatchBytes(command, entries) {
+  return Buffer.byteLength(JSON.stringify({ entries: runtimeLogBatchEntries(command, entries) }));
+}
 function createLiveOutputLogger(config, command, executorKind, protectedValues = [], onMcpToolResults = null, options = {}) {
   const buffers = { stdout: "", stderr: "" };
   const displayCounts = { stdout: 0, stderr: 0, system: 0 };
@@ -35667,6 +35712,16 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
   let liveLogDeliveryFailed = false;
   let failedLiveLogDeliveryCount = 0;
   let skippedLiveLogDeliveryCount = 0;
+  let logEntriesAttempted = 0;
+  let logEntriesAccepted = 0;
+  let logEntriesInvalidDropped = 0;
+  let logEntriesAmbiguousDropped = 0;
+  let logBatchRequestsAttempted = 0;
+  let logBatchRequestsAccepted = 0;
+  let firstLogDeliveryFailureCategory = null;
+  let pendingBatch = [];
+  let pendingBatchBytes = runtimeLogBatchBytes(command, []);
+  let pendingBatchTimer = null;
   const piToolArgumentTracker = executorKind === "pi" ? createPiToolArgumentAmplificationTracker(options.piToolArgumentGuard) : null;
   const fullTranscriptEnabled = executorKind === "pi" && readString(asRecord(asRecord(command).payload).transcriptDetail) === AMASTER_RUNTIME_TRANSCRIPT_DETAIL_FULL;
   const maxEntriesPerStream = parsePositiveInteger(
@@ -35723,34 +35778,66 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     }
     nonProgressEventCount += 1;
   };
-  const deliverLiveLog = async (entry, options2 = {}) => {
+  const deliverLiveLogBatch = async (entries, options2 = {}) => {
+    if (entries.length === 0) return;
     const terminalSummary = options2.terminalSummary === true;
-    if (liveLogDeliveryFailed && !terminalSummary) {
-      skippedLiveLogDeliveryCount += 1;
+    const bisectRecovery = options2.bisectRecovery === true;
+    if (liveLogDeliveryFailed && !terminalSummary && !bisectRecovery) {
+      skippedLiveLogDeliveryCount += entries.length;
       return;
     }
-    let deliveryFailed = false;
-    await ingestLog(
-      config,
-      command,
-      entry.stream,
-      entry.level,
-      truncateText(entry.message),
-      entry.payload ?? {},
-      {
-        timeoutMs: 1e3,
-        onError: (message) => {
-          deliveryFailed = true;
-          process.stderr.write(terminalSummary ? `${message}; terminal live-log summary was not delivered
+    let deliveryError = null;
+    if (!bisectRecovery) logEntriesAttempted += entries.length;
+    logBatchRequestsAttempted += 1;
+    const response = await ingestLogBatch(config, command, entries, {
+      timeoutMs: 1e3,
+      onError: (_message, error) => {
+        deliveryError = error;
+      }
+    });
+    if (response) {
+      logEntriesAccepted += readNumber(response.acceptedCount, entries.length);
+      logBatchRequestsAccepted += 1;
+      return;
+    }
+    if (Number(deliveryError?.httpStatus) === 400) {
+      firstLogDeliveryFailureCategory ??= "invalid";
+      if (entries.length === 1) {
+        logEntriesInvalidDropped += 1;
+        failedLiveLogDeliveryCount += 1;
+        return;
+      }
+      const midpoint = Math.floor(entries.length / 2);
+      const recoveryOptions = { ...options2, bisectRecovery: true };
+      await deliverLiveLogBatch(entries.slice(0, midpoint), recoveryOptions);
+      await deliverLiveLogBatch(entries.slice(midpoint), recoveryOptions);
+      return;
+    }
+    firstLogDeliveryFailureCategory ??= "ambiguous";
+    logEntriesAmbiguousDropped += entries.length;
+    if (!terminalSummary) liveLogDeliveryFailed = true;
+    const message = `AMaster daemon could not determine whether ${entries.length} runtime log entr${entries.length === 1 ? "y was" : "ies were"} accepted`;
+    process.stderr.write(terminalSummary ? `${message}; terminal live-log summary was not delivered
 ` : `${message}; suppressing remaining live logs for this executor turn
 `);
-        }
-      }
-    );
-    if (deliveryFailed) {
-      liveLogDeliveryFailed = true;
-      failedLiveLogDeliveryCount += 1;
+    failedLiveLogDeliveryCount += 1;
+  };
+  const flushPendingBatch = () => {
+    if (pendingBatchTimer) {
+      clearTimeout(pendingBatchTimer);
+      pendingBatchTimer = null;
     }
+    if (pendingBatch.length === 0) return;
+    const entries = pendingBatch;
+    pendingBatch = [];
+    pendingBatchBytes = runtimeLogBatchBytes(command, []);
+    queue = queue.then(() => deliverLiveLogBatch(entries)).catch(() => {
+    });
+  };
+  const schedulePendingBatch = () => {
+    if (pendingBatchTimer) return;
+    pendingBatchTimer = setTimeout(() => flushPendingBatch(), RUNTIME_LOG_BATCH_FLUSH_MS);
+    pendingBatchTimer.unref?.();
   };
   const enqueue = (entry) => {
     const stream = entry.stream === "stderr" || entry.stream === "system" ? entry.stream : "stdout";
@@ -35759,8 +35846,19 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       return;
     }
     displayCounts[stream] = (displayCounts[stream] ?? 0) + 1;
-    queue = queue.then(() => deliverLiveLog(entry)).catch(() => {
-    });
+    const entryBytes = runtimeLogBatchEntryBytes(command, entry);
+    let candidateBatchBytes = pendingBatchBytes + (pendingBatch.length > 0 ? 1 : 0) + entryBytes;
+    if (pendingBatch.length > 0 && (pendingBatch.length >= RUNTIME_LOG_BATCH_MAX_ENTRIES || candidateBatchBytes > RUNTIME_LOG_BATCH_MAX_BYTES)) {
+      flushPendingBatch();
+      candidateBatchBytes = pendingBatchBytes + entryBytes;
+    }
+    pendingBatch.push(entry);
+    pendingBatchBytes = candidateBatchBytes;
+    if (pendingBatch.length >= RUNTIME_LOG_BATCH_MAX_ENTRIES || pendingBatchBytes >= RUNTIME_LOG_BATCH_MAX_BYTES) {
+      flushPendingBatch();
+    } else {
+      schedulePendingBatch();
+    }
   };
   const shouldSuppressDuplicatePiAgentMessage = (entry) => {
     if (executorKind !== "pi") return false;
@@ -35890,22 +35988,25 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       }
       await observationQueue;
       if (observationError) throw observationError;
+      flushPendingBatch();
       await queue;
       const suppressedSummaries = Object.entries(suppressedCounts).filter(([, count2]) => count2 > 0).map(([stream, count2]) => ({ stream, count: count2 }));
-      if (suppressedSummaries.length > 0) {
+      if (suppressedSummaries.length > 0 || liveLogDeliveryFailed) {
         const suppressedCount = suppressedSummaries.reduce((total, summary) => total + summary.count, 0);
-        await deliverLiveLog({
+        await deliverLiveLogBatch([{
           stream: "system",
-          level: "info",
-          message: `Runtime output summarized: ${suppressedCount} event(s) suppressed after ${maxEntriesPerStream} live log entries per stream`,
+          level: liveLogDeliveryFailed ? "warn" : "info",
+          message: liveLogDeliveryFailed ? `Runtime output delivery was incomplete: ${logEntriesAmbiguousDropped} entr${logEntriesAmbiguousDropped === 1 ? "y" : "ies"} had an ambiguous server outcome` : `Runtime output summarized: ${suppressedCount} event(s) suppressed after ${maxEntriesPerStream} live log entries per stream`,
           payload: {
             presentationKind: "output_summary",
             executorKind,
             suppressedCount,
             suppressedByStream: suppressedSummaries,
-            maxEntriesPerStream
+            maxEntriesPerStream,
+            deliveryIncomplete: liveLogDeliveryFailed,
+            ambiguousDropped: logEntriesAmbiguousDropped
           }
-        }, { terminalSummary: true });
+        }], { terminalSummary: true });
       }
     },
     hasStream(stream) {
@@ -35930,10 +36031,17 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       const normalizedFloodLimitBytes = readNumber(floodLimitBytes, 0);
       return {
         liveLogDelivery: {
-          status: liveLogDeliveryFailed ? "partial" : "complete",
+          status: liveLogDeliveryFailed || logEntriesInvalidDropped > 0 ? "partial" : "complete",
           failed: failedLiveLogDeliveryCount,
           skipped: skippedLiveLogDeliveryCount
         },
+        logEntriesAttempted,
+        logEntriesAccepted,
+        logEntriesInvalidDropped,
+        logEntriesAmbiguousDropped,
+        logBatchRequestsAttempted,
+        logBatchRequestsAccepted,
+        ...firstLogDeliveryFailureCategory ? { firstLogDeliveryFailureCategory } : {},
         rawBytesByStream,
         rawOutputBytes,
         retainedBytesByStream,
@@ -36573,6 +36681,15 @@ async function ingestLog(config, command, stream, level, message, payload = {},
     payload
   }, options);
 }
+async function ingestLogBatch(config, command, entries, options = {}) {
+  const connectorId = requireConnectorId(config);
+  return await bestEffortPostJson(
+    config,
+    `/api/amaster/runtime-connectors/${connectorId}/ingest/logs/batch`,
+    { entries: runtimeLogBatchEntries(command, entries) },
+    options
+  );
+}
 function parsedUsageCostCents(usage) {
   const costUsd = readNumber(asRecord(usage).costUsd, 0);
   if (!Number.isFinite(costUsd) || costUsd <= 0) return 0;

package/dist/amaster-runtime.mjs

@@ -7,7 +7,7 @@ import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 import { BUILD_SUPPORTED_CAPABILITIES } from "./amaster-runtime-daemon/capability-registry.mjs";
 
-const CONNECTOR_VERSION = "0.1.1-beta.255";
+const CONNECTOR_VERSION = "0.1.1-beta.256";
 
 const CONFIG_KEY_MAP = new Map([
   ["server_url", "AMASTER_EMPLOYEE_SERVER_URL"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.255",
+  "version": "0.1.1-beta.256",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",