agent-relay-server 0.121.5 → 0.122.1

package/runner/src/adapters/codex-agent-message-capture.ts

@@ -0,0 +1,139 @@
+type EmitAgentMessage = (body: string) => void;
+type ResponseEntry = { itemId?: string; body: string };
+type CompleteItemOptions = { includeInResponse?: boolean; phase?: unknown };
+
+const MAX_CAPTURED_RESPONSE_CHARS = 16_000;
+const TRUNCATION_MARKER_PREFIX = "[truncated:";
+const TERSE_FINAL_MAX_CHARS = 280;
+
+export class CodexAgentMessageCapture {
+  private segments: ResponseEntry[][] = [];
+  private currentSegment: ResponseEntry[] = [];
+  private readonly buffers = new Map<string, string>();
+  private readonly flushedLengths = new Map<string, number>();
+  private readonly responseRecordedLengths = new Map<string, number>();
+
+  reset(): void {
+    this.segments = [];
+    this.currentSegment = [];
+    this.buffers.clear();
+    this.flushedLengths.clear();
+    this.responseRecordedLengths.clear();
+  }
+
+  appendDelta(itemId: string | undefined, delta: string): void {
+    if (!itemId || !delta) return;
+    this.buffers.set(itemId, `${this.buffers.get(itemId) ?? ""}${delta}`);
+  }
+
+  completeItem(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage, options: CompleteItemOptions = {}): void {
+    const fullText = text ?? (itemId ? this.buffers.get(itemId) : undefined);
+    this.flushText(itemId, fullText, emit);
+    if (options.includeInResponse === false || options.phase === "commentary") {
+      this.forgetResponseItem(itemId);
+    } else {
+      this.recordResponseText(itemId, fullText);
+    }
+    if (!itemId) return;
+    this.buffers.delete(itemId);
+    this.flushedLengths.delete(itemId);
+  }
+
+  closeSegment(emit: EmitAgentMessage): void {
+    this.flushPending(emit);
+    if (!this.currentSegment.length) return;
+    this.segments.push(this.currentSegment);
+    this.currentSegment = [];
+  }
+
+  finish(emit: EmitAgentMessage): string | undefined {
+    this.closeSegment(emit);
+    const selectedSegments = selectResponseSegments(this.segments);
+    this.segments = [];
+    const text = selectedSegments.length ? selectedSegments.map(segmentBody).join("\n\n").trim() : undefined;
+    return truncateCapturedResponse(text);
+  }
+
+  private flushPending(emit: EmitAgentMessage): void {
+    for (const [itemId, text] of [...this.buffers.entries()]) {
+      this.flushText(itemId, text, emit);
+      this.recordResponseText(itemId, text);
+    }
+  }
+
+  private flushText(itemId: string | undefined, text: string | undefined, emit: EmitAgentMessage): void {
+    if (!text) return;
+    const offset = itemId ? (this.flushedLengths.get(itemId) ?? 0) : 0;
+    const chunk = text.slice(offset);
+    if (itemId) this.flushedLengths.set(itemId, text.length);
+    const body = chunk.trim();
+    if (!body) return;
+    emit(body);
+  }
+
+  private recordResponseText(itemId: string | undefined, text: string | undefined): void {
+    if (!text) return;
+    const body = text.trim();
+    if (!body) return;
+    if (itemId) {
+      const offset = this.responseRecordedLengths.get(itemId) ?? 0;
+      const chunk = text.slice(offset).trim();
+      this.responseRecordedLengths.set(itemId, text.length);
+      if (!chunk) return;
+      this.currentSegment.push({ itemId, body: chunk });
+      return;
+    }
+    this.currentSegment.push({ body });
+  }
+
+  private forgetResponseItem(itemId: string | undefined): void {
+    if (!itemId) return;
+    this.responseRecordedLengths.delete(itemId);
+    this.currentSegment = this.currentSegment.filter((entry) => entry.itemId !== itemId);
+    this.segments = this.segments
+      .map((segment) => segment.filter((entry) => entry.itemId !== itemId))
+      .filter((segment) => segment.length > 0);
+  }
+}
+
+function selectResponseSegments(segments: ResponseEntry[][]): ResponseEntry[][] {
+  const nonEmptySegments = segments.filter((segment) => segment.length > 0);
+  const finalSegment = nonEmptySegments.at(-1);
+  if (!finalSegment) return [];
+  const finalBody = segmentBody(finalSegment);
+  if (!isTerseTerminalStatus(finalBody)) return [finalSegment];
+
+  // Codex often posts the real wrap-up across multiple assistant segments before a
+  // final workspace-ready/status line. Keep contiguous substantive segments after
+  // the last procedural assistant segment, then append the terminal status.
+  const selectedSegments: ResponseEntry[][] = [];
+  for (let index = nonEmptySegments.length - 2; index >= 0; index -= 1) {
+    const candidate = nonEmptySegments[index];
+    if (!candidate || !isSubstantiveResponseSegment(segmentBody(candidate))) break;
+    selectedSegments.unshift(candidate);
+  }
+  return [...selectedSegments, finalSegment];
+}
+
+function segmentBody(segment: ResponseEntry[]): string {
+  return segment.map((entry) => entry.body).join("\n\n").trim();
+}
+
+function isTerseTerminalStatus(body: string): boolean {
+  if (body.length > TERSE_FINAL_MAX_CHARS) return false;
+  if (/\n\s*(?:[-*]|\d+\.)\s+/.test(body)) return false;
+  return /\b(?:landed|ready for review|handed off|no further action|done|complete|completed|committed|merged)\b/i.test(body);
+}
+
+function isSubstantiveResponseSegment(body: string): boolean {
+  if (body.length >= 120) return true;
+  if (/\n\s*(?:[-*]|\d+\.)\s+/.test(body)) return true;
+  if (/\*\*(?:what changed|changes?|tests?|gates?|verification|risks?|residual risk|summary)\b/i.test(body)) return true;
+  if (/^#{1,3}\s+\S/m.test(body)) return true;
+  return body.split(/\n{2,}/).length >= 2;
+}
+
+function truncateCapturedResponse(text: string | undefined): string | undefined {
+  if (!text || text.length <= MAX_CAPTURED_RESPONSE_CHARS) return text;
+  return `${text.slice(0, MAX_CAPTURED_RESPONSE_CHARS).trimEnd()}\n\n${TRUNCATION_MARKER_PREFIX} showing first ${MAX_CAPTURED_RESPONSE_CHARS} of ${text.length} chars]`;
+}

package/runner/src/adapters/codex-client.ts

@@ -0,0 +1,279 @@
+import { setTimeout as delay } from "node:timers/promises";
+
+type JsonRpcId = number | string;
+
+type JsonRpcRequest = {
+  id: JsonRpcId;
+  method: string;
+  params?: unknown;
+};
+
+type JsonRpcResponse = {
+  id: JsonRpcId;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+};
+
+type JsonRpcNotification = {
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+type ThreadStatus =
+  | { type: "notLoaded" }
+  | { type: "idle" }
+  | { type: "systemError" }
+  | { type: "active"; activeFlags: string[] };
+
+type TurnStatus = "completed" | "interrupted" | "failed" | "inProgress";
+
+interface Turn {
+  id: string;
+  status: TurnStatus;
+  startedAt: number | null;
+  completedAt: number | null;
+}
+
+export interface Thread {
+  id: string;
+  cwd: string;
+  status: ThreadStatus;
+  updatedAt: number;
+  preview: string;
+  turns?: Turn[];
+}
+
+export type ClientEvent =
+  | { type: "notification"; message: JsonRpcNotification }
+  | { type: "server-request"; message: JsonRpcRequest }
+  | { type: "response"; message: JsonRpcResponse };
+
+interface TurnStartResponse {
+  turn: Turn;
+}
+
+interface ThreadStartResponse {
+  thread: Thread;
+}
+
+interface ThreadResumeResponse {
+  thread: Thread;
+}
+
+interface ThreadReadResponse {
+  thread: Thread;
+}
+
+interface ThreadListResponse {
+  data: Thread[];
+  nextCursor: string | null;
+}
+
+interface ThreadLoadedListResponse {
+  data: string[];
+  nextCursor: string | null;
+}
+
+interface AccountRateLimitsResponse {
+  rateLimits?: unknown;
+  rate_limits?: unknown;
+}
+
+export const CODEX_APP_CLIENT_EVENT_CAP = 5_000;
+
+export class CodexAppClient {
+  private ws!: WebSocket;
+  private nextId = 1;
+  private pending = new Map<JsonRpcId, { resolve: (value: any) => void; reject: (err: unknown) => void }>();
+  private events: ClientEvent[] = [];
+  private listeners = new Set<(event: ClientEvent) => void>();
+  private connected = false;
+  private connectionListeners = new Set<(connected: boolean) => void>();
+
+  constructor(private readonly url: string, private readonly log: (msg: string) => void = () => {}) {}
+
+  async connect(): Promise<void> {
+    if (this.connected) return;
+    await new Promise<void>((resolve, reject) => {
+      const ws = new WebSocket(this.url);
+      this.ws = ws;
+
+      ws.onopen = () => {
+        this.connected = true;
+        this.emitConnection(true);
+        resolve();
+      };
+      ws.onerror = (event) => reject(new Error(`websocket error: ${String((event as ErrorEvent).message || "unknown")}`));
+      ws.onclose = (event) => {
+        this.connected = false;
+        this.emitConnection(false);
+        const err = new Error(`websocket closed code=${event.code} reason=${event.reason || "(none)"}`);
+        for (const pending of this.pending.values()) pending.reject(err);
+        this.pending.clear();
+      };
+      ws.onmessage = (event) => this.handleMessage(String(event.data));
+    });
+  }
+
+  close(): void {
+    if (!this.ws) return;
+    this.ws.close();
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  async initialize(): Promise<unknown> {
+    return this.request("initialize", {
+      clientInfo: {
+        name: "agent-relay-runner-codex",
+        title: "Agent Relay Codex Runner",
+        version: "0.1.0",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    });
+  }
+
+  onEvent(listener: (event: ClientEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  onConnectionChange(listener: (connected: boolean) => void): () => void {
+    this.connectionListeners.add(listener);
+    return () => this.connectionListeners.delete(listener);
+  }
+
+  getEvents(): ClientEvent[] {
+    return [...this.events];
+  }
+
+  async settle(ms = 150): Promise<void> {
+    await delay(ms);
+  }
+
+  async threadStart(params: Record<string, unknown>): Promise<ThreadStartResponse> {
+    return this.request<ThreadStartResponse>("thread/start", params);
+  }
+
+  async threadResume(params: Record<string, unknown>): Promise<ThreadResumeResponse> {
+    return this.request<ThreadResumeResponse>("thread/resume", params);
+  }
+
+  async threadRead(threadId: string, includeTurns = false): Promise<ThreadReadResponse> {
+    return this.request<ThreadReadResponse>("thread/read", { threadId, includeTurns });
+  }
+
+  async threadList(params: Record<string, unknown>): Promise<ThreadListResponse> {
+    return this.request<ThreadListResponse>("thread/list", params);
+  }
+
+  async threadLoadedList(limit = 20): Promise<ThreadLoadedListResponse> {
+    return this.request<ThreadLoadedListResponse>("thread/loaded/list", { limit });
+  }
+
+  async threadCompactStart(threadId: string): Promise<Record<string, never>> {
+    return this.request<Record<string, never>>("thread/compact/start", { threadId });
+  }
+
+  async turnStart(threadId: string, text: string): Promise<TurnStartResponse> {
+    return this.request<TurnStartResponse>("turn/start", {
+      threadId,
+      input: [{ type: "text", text }],
+    });
+  }
+
+  async turnSteer(threadId: string, turnId: string, text: string): Promise<{ turnId: string }> {
+    return this.request<{ turnId: string }>("turn/steer", {
+      threadId,
+      expectedTurnId: turnId,
+      input: [{ type: "text", text }],
+    });
+  }
+
+  async turnInterrupt(threadId: string, turnId: string): Promise<Record<string, never>> {
+    return this.request<Record<string, never>>("turn/interrupt", { threadId, turnId });
+  }
+
+  async accountRateLimitsRead(): Promise<AccountRateLimitsResponse> {
+    return this.request<AccountRateLimitsResponse>("account/rateLimits/read");
+  }
+
+  respondToServerRequest(id: JsonRpcId, result: unknown): void {
+    if (!this.connected) {
+      throw new Error("websocket not connected");
+    }
+    this.ws.send(JSON.stringify({ id, result }));
+  }
+
+  rejectServerRequest(id: JsonRpcId, code: number, message: string, data?: unknown): void {
+    if (!this.connected) {
+      throw new Error("websocket not connected");
+    }
+    this.ws.send(JSON.stringify({ id, error: { code, message, ...(data !== undefined ? { data } : {}) } }));
+  }
+
+  private async request<T = unknown>(method: string, params?: unknown): Promise<T> {
+    if (!this.connected) {
+      throw new Error("websocket not connected");
+    }
+    const id = this.nextId++;
+    const payload: JsonRpcRequest = { id, method, params };
+    const promise = new Promise<T>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    this.ws.send(JSON.stringify(payload));
+    return promise;
+  }
+
+  private handleMessage(raw: string): void {
+    // The frame comes from an external process over a WebSocket; a partial or
+    // malformed frame must not throw out of onmessage and drop the connection.
+    let parsed: JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+    try {
+      parsed = JSON.parse(raw) as JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+    } catch {
+      this.log(`dropped malformed frame (${raw.length} bytes)`);
+      return;
+    }
+
+    if ("id" in parsed && ("result" in parsed || "error" in parsed)) {
+      const pending = this.pending.get(parsed.id);
+      if (pending) {
+        this.pending.delete(parsed.id);
+        if (parsed.error) {
+          pending.reject(new Error(`${parsed.error.message} (${parsed.error.code})`));
+        } else {
+          pending.resolve(parsed.result);
+        }
+      }
+      this.record({ type: "response", message: parsed });
+      return;
+    }
+
+    if ("id" in parsed && "method" in parsed) {
+      this.log(`server-request ${parsed.method}`);
+      this.record({ type: "server-request", message: parsed });
+      return;
+    }
+
+    if ("method" in parsed) {
+      this.record({ type: "notification", message: parsed });
+    }
+  }
+
+  private record(event: ClientEvent): void {
+    this.events.push(event);
+    if (this.events.length > CODEX_APP_CLIENT_EVENT_CAP) {
+      this.events.splice(0, this.events.length - CODEX_APP_CLIENT_EVENT_CAP);
+    }
+    for (const listener of this.listeners) listener(event);
+  }
+
+  private emitConnection(connected: boolean): void {
+    for (const listener of this.connectionListeners) listener(connected);
+  }
+}