agent-relay-runner 0.129.11 → 0.129.13

package/src/runner-helpers.ts

@@ -299,6 +299,16 @@ export function shouldLogDeliveryFailure(error: unknown): boolean {
     && message !== CODEX_TURN_IN_PROGRESS_MESSAGE;
 }
 
+/** The same rejection, seen from the COMMAND side (#1565 F1): a serialized boundary payload that
+ *  met the turn the payload before it started is deferred until that turn ends, not failed. */
+export function isTurnInProgressDeliveryError(error: unknown): boolean {
+  return errMessage(error) === CODEX_TURN_IN_PROGRESS_MESSAGE;
+}
+
+/** Command types that put a payload into the provider's single input channel, and therefore take a
+ *  `ProviderInputQueue` ticket at dispatch so two of them can never interleave (#1565 F1). */
+export const PROVIDER_INPUT_COMMAND_TYPES: ReadonlySet<string> = new Set(["agent.injectContext", "prompt.inject"]);
+
 export function runtimeTokenRenewDelayMs(expiresAtSeconds: number, nowMs = Date.now()): number | undefined {
   const expiresAtMs = expiresAtSeconds * 1000;
   const ttlMs = expiresAtMs - nowMs;

package/src/transcript-context.ts

@@ -0,0 +1,83 @@
+import { readFileSync, statSync } from "node:fs";
+import type { ContextState } from "agent-relay-sdk";
+import type { ProviderContextUsage } from "./adapter";
+
+// #1512: Claude reports context only through its out-of-band status-line probe,
+// which freezes after an in-process compact/clear/native-resume (no new process,
+// so the probe file stops advancing while the agent keeps taking turns). The
+// transcript — handed to the runner every turn by the Stop hook — carries the
+// same per-turn token usage, so the runner derives fresh context from it here as
+// a probe-independent fallback that keeps context.lastUpdatedAt advancing across
+// those in-process generation bumps. Kept out of runner-core to hold that giant's
+// line budget (epic #291); runner-core just threads its per-session cache through.
+
+export interface TranscriptContextCache {
+  path: string;
+  mtimeMs: number;
+  /** Byte size alongside mtime: a same-second rewrite (coarse mtime granularity) still changes length. */
+  size: number;
+  usage: ProviderContextUsage | undefined;
+}
+
+export interface TranscriptContextInput {
+  /** Latest transcript path the Stop hook reported this session. */
+  transcriptPath: string | undefined;
+  /** The transcript-backed adapter's per-turn usage parser (absent for others). */
+  derive: ((jsonl: string) => ProviderContextUsage | undefined) | undefined;
+  /** Context-window size — stable for the session, so reuse what the probe saw. */
+  tokensMax: number | undefined;
+  /** Prior parse, reused when the transcript's (mtime, size) is unchanged (large files). */
+  cache: TranscriptContextCache | undefined;
+  now: number;
+}
+
+// Returns the derived context (or undefined when it can't be computed) and the
+// cache to carry forward. The context-window size is stable for a session, so we
+// reuse the tokensMax the status-line probe reported at least once rather than
+// re-deriving it from a model catalog the runner doesn't hold; the transcript
+// supplies the per-turn tokensUsed. The parse is cached by transcript (mtime, size)
+// so a large log isn't re-read every 30s heartbeat while nothing new has been
+// written. Size is paired with mtime because an in-process compact/clear/resume can
+// rewrite the transcript within the same coarse mtime tick (1s on some filesystems),
+// which mtime alone would miss — leaving stale context; the length still changes.
+export function transcriptDerivedContext(input: TranscriptContextInput): {
+  context: ContextState | undefined;
+  cache: TranscriptContextCache | undefined;
+} {
+  const { transcriptPath, derive, tokensMax, cache, now } = input;
+  if (!transcriptPath || !derive) return { context: undefined, cache };
+  if (typeof tokensMax !== "number" || !Number.isFinite(tokensMax) || tokensMax <= 0) return { context: undefined, cache };
+
+  let nextCache = cache;
+  let usage: ProviderContextUsage | undefined;
+  try {
+    const stat = statSync(transcriptPath);
+    const mtimeMs = stat.mtimeMs;
+    const size = stat.size;
+    if (cache?.path === transcriptPath && cache.mtimeMs === mtimeMs && cache.size === size) {
+      usage = cache.usage;
+    } else {
+      usage = derive(readFileSync(transcriptPath, "utf8"));
+      nextCache = { path: transcriptPath, mtimeMs, size, usage };
+    }
+  } catch {
+    return { context: undefined, cache };
+  }
+  if (!usage) return { context: undefined, cache: nextCache };
+
+  return {
+    context: {
+      utilization: Math.max(0, Math.min(1, usage.tokensUsed / tokensMax)),
+      tokensUsed: usage.tokensUsed,
+      tokensMax,
+      lifecycleState: "working",
+      warmTopics: [],
+      activeMemories: [],
+      tasksSinceCompact: 0,
+      lastUpdatedAt: usage.occurredAt ?? now,
+      source: "api",
+      confidence: "reported",
+    },
+    cache: nextCache,
+  };
+}

package/src/turn-reconcile-event.ts

@@ -0,0 +1,48 @@
+import { RECONCILED_TURN_TIMELINE_STATUS } from "agent-relay-sdk";
+
+// Same shape the runner publishes (structurally identical to the local declarations in
+// runner-core.ts / native-self-resume.ts, which is how the other timeline producers do it).
+interface RunnerTimelineEvent {
+  status: string;
+  id?: string;
+  timestamp: number;
+  title?: string;
+  body?: string;
+  icon?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * #1621 — the announcement for a provider-turn claim the busy backstop force-cleared.
+ *
+ * Reconciliation is a real state change, not bookkeeping repair: the turn the coordinator is
+ * waiting on is over and produced no reply, and `busy` is exactly the signal it used to decide
+ * NOT to intervene. So the clear is EMITTED (the relay turns this event into an activity row plus
+ * an `agent.turn_interrupted` notification for the spawn parent) instead of silently correcting
+ * the card — a quietly-fixed card still leaves the coordinator's plan stalled on a turn that
+ * ended. Pure builder so the payload the parent's notice is derived from is unit-testable without
+ * standing up an AgentRunner.
+ */
+export function reconciledTurnTimelineEvent(input: {
+  turnId: string;
+  reason: string;
+  startedAt: number;
+  now?: number;
+}): RunnerTimelineEvent {
+  const now = input.now ?? Date.now();
+  return {
+    status: RECONCILED_TURN_TIMELINE_STATUS,
+    id: `provider-turn-reconciled-${input.turnId}`,
+    timestamp: now,
+    title: "Provider turn cleared by reconciliation",
+    body: `The provider turn ended without a turn-end signal (${input.reason}); the agent was observed idle at its prompt and is no longer busy.`,
+    icon: "ti-alert-triangle",
+    metadata: {
+      eventType: RECONCILED_TURN_TIMELINE_STATUS,
+      reconcileReason: input.reason,
+      turnId: input.turnId,
+      turnStartedAt: input.startedAt,
+      turnAgeMs: Math.max(0, now - input.startedAt),
+    },
+  };
+}