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

package/dist/amaster-runtime-daemon.mjs

@@ -27,7 +27,7 @@ var toolNames = /* @__PURE__ */ new Set([
   "list_goals",
   "create_issue",
   "update_issue",
-  "add_comment"
+  "add_issue_comment"
 ]);
 function validDelivery(value) {
   if (!record(value) || !uuid(value.turnId) || !uuid(value.companyId) || !uuid(value.conversationId) || !text(value.token, 64) || !/^[a-f0-9]{64}$/.test(value.token) || !(value.model === null || text(value.model, 200)))
@@ -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(),
@@ -30096,7 +30122,7 @@ function runtimeDecompositionRequirementText(context) {
     "Create the complete real direct child graph before doing any substantial source work.",
     "Before browsing, searching, commenting, or doing any source work, call runtime_action_describe for record_work_disposition with dispositionKind create_children and for every child action type you need.",
     "Persist one immutable runtime_action_plan whose first action is record_work_disposition kind create_children and whose remaining actions are exactly the complete child graph referenced by that disposition. Do not append update_parent, add_comment, upsert_document, or any other action after the child graph.",
-    "For each record_work_disposition structure child, copy scopeSummary exactly into the bound create_child_task description. The Server compares those normalized strings and rejects a missing or different description with work_disposition_child_scope_mismatch; delegation.objective does not satisfy that binding. Also copy ownerAgentId exactly into the bound create_child_task assigneeAgentId; mentioning an owner in delegation prose or title does not assign the child, and a missing or different explicit assignee is rejected with work_disposition_child_owner_binding_mismatch.",
+    "For each record_work_disposition structure child, copy scopeSummary exactly into the bound create_child_issue description. The Server compares those normalized strings and rejects a missing or different description with work_disposition_child_scope_mismatch; delegation.objective does not satisfy that binding. Also copy ownerAgentId exactly into the bound create_child_issue assigneeAgentId; mentioning an owner in delegation prose or title does not assign the child, and a missing or different explicit assignee is rejected with work_disposition_child_owner_binding_mismatch.",
     "Execute that exact plan with runtime_action_commit.",
     "Once runtime_action_commit succeeds, the committed required child graph is this parent run's durable delegated live disposition.",
     "After runtime_action_commit succeeds, yield and end the parent run immediately. Do not browse, search, research, or execute any delegated child acceptance scope, and do not poll child runs. Child assignment runs are the sole execution path for delegated child scope.",
@@ -33516,7 +33542,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.254";
+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.254";
+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.254",
+  "version": "0.1.1-beta.256",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",