Function serveReplayBrain

e2e/src/clients/replay-brain.ts:93–208

(
  respond: (ctx: BrainContext) => BrainResponse,
)

 * `respond` is called once per chat-completions request.
 */
export const serveReplayBrain = (
  respond: (ctx: BrainContext) => BrainResponse,
): Effect.Effect<ReplayBrain, never, Scope.Scope> =>
  Effect.acquireRelease(
    Effect.callback<{ server: Server; brain: ReplayBrain }>((resume) => {
      const served: BrainRequest[] = [];
      const errors: string[] = [];

      const server = createServer((request, response) => {
        if (!request.url?.includes("/chat/completions")) {
          response.writeHead(404).end();
          return;
        }
        let raw = "";
        request.on("data", (piece: Buffer) => (raw += piece.toString("utf8")));
        request.on("end", () => {
          const body = JSON.parse(raw || "{}") as WireBody;
          const messages = (body.messages ?? []).map((message) => ({
            role: message.role,
            content: contentText(message.content),
          }));
          const toolNames = (body.tools ?? [])
            .map((tool) => tool.function?.name ?? "")
            .filter(Boolean);
          const requestIndex = served.length;
          served.push({ messages, toolNames });

          const lastOf = (role: string) =>
            [...messages].reverse().find((message) => message.role === role)?.content;

          let scripted: BrainResponse;
          // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: a throwing script must surface as a recorded error + a stop response, not a hung agent
          try {
            scripted = respond({
              requestIndex,
              lastRole: messages.at(-1)?.role ?? "",
              lastUser: lastOf("user") ?? "",
              lastToolResult: lastOf("tool"),
              toolNames,
            });
          } catch (error) {
            errors.push(`respond() threw on request ${requestIndex}: ${String(error)}`);
            scripted = { text: "(replay brain script error)" };
          }

          // Resolve a scripted tool name against the agent's namespaced names.
          let resolvedTool: { name: string; args: unknown } | undefined;
          if (scripted.tool) {
            const wanted = scripted.tool.name;
            const match =
              toolNames.find((name) => name === wanted) ??
              toolNames.find((name) => name.endsWith(wanted));
            if (match) {
              resolvedTool = { name: match, args: scripted.tool.args };
            } else {
              errors.push(
                `request ${requestIndex}: no offered tool matches "${wanted}" (offered: ${toolNames.join(", ")})`,
              );