agent-relay-server 0.121.5 → 0.122.1

package/runner/src/config.ts

@@ -6,6 +6,7 @@ import { DEFAULT_RELAY_URL, RELAY_TOKEN_HEADER, errMessage, stringValue } from "
 import type { SettingEntry, WorkspaceMetadata } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { getManifest } from "agent-relay-providers";
+export { messageBodyMaxCharsFromEnv } from "./message-body-config";
 
 interface ProviderConfig {
   command: string;
@@ -241,10 +242,6 @@ export function providerHomeRootFromEnv(): string {
   return process.env.AGENT_RELAY_PROVIDER_HOME_ROOT || join(homedir(), ".agent-relay", "provider-homes");
 }
 
-export function messageBodyMaxCharsFromEnv(): string | undefined {
-  return process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
-}
-
 export function loadProviderConfig(provider: string, home = agentRelayHome()): LoadedProviderConfig {
   const path = join(providersDir(home), `${provider}.json`);
   const raw = readJson(path);

package/runner/src/context-probe-state.ts

@@ -0,0 +1,6 @@
+import { readContextProbeState } from "agent-relay-sdk/context-probe";
+import { contextStateDirFromEnv } from "./config";
+
+export function readRunnerContextProbeState(agentId: string) {
+  return readContextProbeState(agentId, contextStateDirFromEnv());
+}

package/runner/src/continuation-archive.ts

@@ -0,0 +1,179 @@
+import type { RelayHttpClient } from "agent-relay-sdk";
+import type { OutboxRecord } from "./outbox";
+
+const CONTINUATION_ARCHIVE_MAX_POST_BODY_BYTES = 64 * 1024;
+const CONTINUATION_ARCHIVE_CHUNK_TARGET_BYTES = 56 * 1024;
+const CONTINUATION_ARCHIVE_MAX_GENERATION_BYTES = 8 * 1024 * 1024;
+const encoder = new TextEncoder();
+const fatalUtf8Decoder = new TextDecoder("utf-8", { fatal: true });
+
+interface ContinuationArchiveOutboxPayload {
+  agentId: string;
+  segment: string;
+  generation?: number;
+  deliveredChunks?: number;
+  totalChunks?: number;
+}
+
+interface ContinuationArchiveResponse {
+  archive?: { generation?: unknown };
+}
+
+export function boundContinuationArchiveSegment(segment: string): { segment: string; keptBytes: number; droppedBytes: number } {
+  const encoded = encoder.encode(segment);
+  const bytes = encoded.byteLength;
+  if (bytes <= CONTINUATION_ARCHIVE_MAX_GENERATION_BYTES) {
+    return { segment, keptBytes: bytes, droppedBytes: 0 };
+  }
+  const bounded = decodeUtf8Prefix(encoded, CONTINUATION_ARCHIVE_MAX_GENERATION_BYTES);
+  const keptBytes = utf8Bytes(bounded);
+  return { segment: bounded.trimEnd(), keptBytes, droppedBytes: bytes - keptBytes };
+}
+
+export async function deliverContinuationArchiveRecord(input: {
+  record: OutboxRecord;
+  http: Pick<RelayHttpClient, "recordContinuationArchive">;
+  updatePayload: (seq: number, payload: unknown) => void;
+  sessionLog: (message: string) => void;
+}): Promise<void> {
+  const payload = input.record.payload as ContinuationArchiveOutboxPayload;
+  let segment = payload.segment;
+  if (!payload.agentId || typeof segment !== "string") throw new Error("invalid continuation archive outbox payload");
+
+  const bounded = boundContinuationArchiveSegment(segment);
+  if (bounded.droppedBytes > 0) {
+    segment = bounded.segment;
+    input.sessionLog(`continuation archive truncated at ${bounded.keptBytes} bytes; dropped ${bounded.droppedBytes} bytes before delivery`);
+    input.updatePayload(input.record.seq, { ...payload, segment, deliveredChunks: 0, totalChunks: undefined, generation: undefined });
+  }
+
+  const chunks = splitContinuationArchiveSegment({
+    agentId: payload.agentId,
+    segment,
+    occurredAt: input.record.occurredAt,
+  });
+  const knownGeneration = Number.isSafeInteger(payload.generation) ? payload.generation : undefined;
+  const deliveredChunks = knownGeneration === undefined ? 0 : Math.max(0, Math.min(payload.deliveredChunks ?? 0, chunks.length));
+  let generation = knownGeneration;
+
+  for (let index = deliveredChunks; index < chunks.length; index += 1) {
+    const request = {
+      agentId: payload.agentId,
+      segment: chunks[index]!,
+      occurredAt: input.record.occurredAt,
+      ...(generation !== undefined ? { generation } : {}),
+    };
+    assertContinuationArchivePostFits(request);
+    const response = await input.http.recordContinuationArchive(request) as ContinuationArchiveResponse;
+    const returnedGeneration = archiveGeneration(response);
+    if (generation === undefined) {
+      if (returnedGeneration === undefined) throw new Error("continuation archive response missing generation");
+      generation = returnedGeneration;
+    } else if (returnedGeneration !== undefined && returnedGeneration !== generation) {
+      throw new Error(`continuation archive generation mismatch: expected ${generation}, got ${returnedGeneration}`);
+    }
+    input.updatePayload(input.record.seq, {
+      ...payload,
+      segment,
+      generation,
+      deliveredChunks: index + 1,
+      totalChunks: chunks.length,
+    } satisfies ContinuationArchiveOutboxPayload);
+  }
+}
+
+function splitContinuationArchiveSegment(input: { agentId: string; segment: string; occurredAt: number }): string[] {
+  const chunks: string[] = [];
+  let current = "";
+  for (const line of transcriptLines(input.segment)) {
+    if (!line) continue;
+    if (fitsContinuationArchiveChunk(input.agentId, line, input.occurredAt)) {
+      const next = current ? current + line : line;
+      if (utf8Bytes(next) <= CONTINUATION_ARCHIVE_CHUNK_TARGET_BYTES && fitsContinuationArchiveChunk(input.agentId, next, input.occurredAt)) {
+        current = next;
+        continue;
+      }
+      if (current) chunks.push(current.trimEnd());
+      current = line;
+      continue;
+    }
+    if (current) {
+      chunks.push(current.trimEnd());
+      current = "";
+    }
+    chunks.push(...splitLongContinuationArchiveLine(input.agentId, line, input.occurredAt));
+  }
+  if (current) chunks.push(current.trimEnd());
+  return chunks.filter((chunk) => chunk.length > 0);
+}
+
+function transcriptLines(segment: string): string[] {
+  const lines = segment.match(/[^\n]*(?:\n|$)/g) ?? [segment];
+  return lines.filter((line) => line.length > 0);
+}
+
+function splitLongContinuationArchiveLine(agentId: string, line: string, occurredAt: number): string[] {
+  const chars = Array.from(line);
+  const chunks: string[] = [];
+  let offset = 0;
+  while (offset < chars.length) {
+    let low = 1;
+    let high = chars.length - offset;
+    let best = 0;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const candidate = chars.slice(offset, offset + mid).join("");
+      if (utf8Bytes(candidate) <= CONTINUATION_ARCHIVE_CHUNK_TARGET_BYTES && fitsContinuationArchiveChunk(agentId, candidate, occurredAt)) {
+        best = mid;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    if (best === 0) throw new Error("continuation archive chunk budget cannot fit one character");
+    chunks.push(chars.slice(offset, offset + best).join(""));
+    offset += best;
+  }
+  return chunks;
+}
+
+function fitsContinuationArchiveChunk(agentId: string, segment: string, occurredAt: number): boolean {
+  return continuationArchivePostBytes({
+    agentId,
+    segment,
+    occurredAt,
+    generation: Number.MAX_SAFE_INTEGER,
+  }) < CONTINUATION_ARCHIVE_MAX_POST_BODY_BYTES;
+}
+
+function assertContinuationArchivePostFits(input: { agentId: string; segment: string; occurredAt: number; generation?: number }): void {
+  const bytes = continuationArchivePostBytes(input);
+  if (bytes >= CONTINUATION_ARCHIVE_MAX_POST_BODY_BYTES) {
+    throw new Error(`continuation archive chunk JSON body is ${bytes} bytes; max is ${CONTINUATION_ARCHIVE_MAX_POST_BODY_BYTES - 1}`);
+  }
+}
+
+function continuationArchivePostBytes(input: { agentId: string; segment: string; occurredAt: number; generation?: number }): number {
+  return utf8Bytes(JSON.stringify(input));
+}
+
+function archiveGeneration(response: ContinuationArchiveResponse): number | undefined {
+  const generation = response.archive?.generation;
+  return typeof generation === "number" && Number.isSafeInteger(generation) && generation >= 0 ? generation : undefined;
+}
+
+function decodeUtf8Prefix(bytes: Uint8Array, maxBytes: number): string {
+  let end = Math.min(maxBytes, bytes.byteLength);
+  while (end > 0) {
+    try {
+      return fatalUtf8Decoder.decode(bytes.subarray(0, end));
+    } catch {
+      end -= 1;
+    }
+  }
+  return "";
+}
+
+function utf8Bytes(value: string): number {
+  return encoder.encode(value).byteLength;
+}