// Replay brain: a local server speaking the OpenAI chat-completions wire// (SSE streaming, tool calls) that a REAL agent (OpenCode) uses as its LLM.// The scenario scripts the brain; the agent does everything else for real —// TUI rendering, MCP discovery/auth, tool execution against the target,// result round-trips. "Replay brain, real hands": deterministic conversation,// zero modeled client behavior.//// The brain is a state machine, not a fixed turn list: each request gets a// normalized view of the conversation so far and the scenario's `respond`// callback decides what the "model" says next (text, a tool call, or both).// That lets a script absorb variable-length detours — approval pauses that// need a resume call, retries — without index bookkeeping.import { createServer, type Server } from "node:http";import type { AddressInfo } from "node:net"; import { Effect, Scope } from "effect"; /** What the scenario's script sees per request. */export interface BrainContext {  /** 0-based count of requests served before this one. */  readonly requestIndex: number;  /** Role of the final message — "user" means a fresh human turn, "tool"   *  means the agent is returning a tool result for the brain to continue. */  readonly lastRole: string;  /** The latest user-role message content (the human's chat input). */  readonly lastUser: string;  /** The latest tool-role message content (last tool result), if any. */  readonly lastToolResult: string | undefined;  /** Tool names offered in this request (already namespaced by the agent). */  readonly toolNames: ReadonlyArray<string>;} /** What the "model" does next. `tool.name` may be a suffix — the brain *  resolves it against the request's offered tool names, so scripts don't *  hardcode the agent's MCP namespacing. */export interface BrainResponse {  readonly text?: string;  readonly tool?: { readonly name: string; readonly args: unknown };} export interface ReplayBrain {  /** Base URL for the agent's provider config (…/v1). */  readonly baseUrl: string;  /** Every request body served, in order (for post-hoc assertions). */  readonly requests: () => ReadonlyArray<BrainRequest>;  /** Script errors (mismatched expectations, throws) — assert empty. */  readonly errors: () => ReadonlyArray<string>;} export interface BrainRequest {  readonly messages: ReadonlyArray<{ role: string; content: string }>;  readonly toolNames: ReadonlyArray<string>;} interface WireMessage {  readonly role: string;  readonly content?: unknown;  readonly tool_calls?: ReadonlyArray<unknown>;} interface WireBody {  readonly messages?: ReadonlyArray<WireMessage>;  readonly tools?: ReadonlyArray<{ function?: { name?: string } }>;} const contentText = (content: unknown): string => {  if (typeof content === "string") return content;  if (Array.isArray(content)) {    return content      .map((part) =>        typeof part === "object" && part !== null && "text" in part          ? String((part as { text: unknown }).text)          : "",      )      .join("");  }  return "";}; const sseChunk = (delta: Record<string, unknown>, finish: string | null) =>  `data: ${JSON.stringify({    id: "chatcmpl-replay",    object: "chat.completion.chunk",    created: 0,    model: "replay-model",    choices: [{ index: 0, delta, finish_reason: finish }],  })}\n\n`; /** * Serve a scripted brain for the lifetime of the surrounding scope. * `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(", ")})`,              );            }          }           response.writeHead(200, {            "content-type": "text/event-stream",            "cache-control": "no-cache",            connection: "keep-alive",          });          response.write(sseChunk({ role: "assistant" }, null));          if (scripted.text) {            // A few chunks so the TUI streams like a real model reply.            for (const piece of scripted.text.match(/.{1,24}/gs) ?? []) {              response.write(sseChunk({ content: piece }, null));            }          }          if (resolvedTool) {            response.write(              sseChunk(                {                  tool_calls: [                    {                      index: 0,                      id: `call_${requestIndex}`,                      type: "function",                      function: {                        name: resolvedTool.name,                        arguments: JSON.stringify(resolvedTool.args ?? {}),                      },                    },                  ],                },                null,              ),            );          }          response.write(sseChunk({}, resolvedTool ? "tool_calls" : "stop"));          response.write("data: [DONE]\n\n");          response.end();        });      });       server.listen(0, "127.0.0.1", () => {        const { port } = server.address() as AddressInfo;        resume(          Effect.succeed({            server,            brain: {              baseUrl: `http://127.0.0.1:${port}/v1`,              requests: () => served,              errors: () => errors,            },          }),        );      });    }),    (resource: { server: Server; brain: ReplayBrain }) =>      Effect.sync(() => void resource.server.close()),  ).pipe(Effect.map(({ brain }) => brain));