API content objects are silently stringified as [object Object]

From the repository root, save this as repro_api_content_object_stringification.mts and run:

pnpm install --frozen-lockfile
pnpm exec tsx repro_api_content_object_stringification.mts

import { Readable } from "node:stream";
import { ApiServerChannel } from "./src/adapters/channel/api-server/ApiServerChannel.js";
import { ApiServerSessionMapper } from "./src/adapters/channel/api-server/ApiServerSessionMapper.js";
import type { Gateway, GatewayEvent, GatewaySubmitTurnInput } from "./src/gateway/index.js";

type CaptureResponse = {
  statusCode: number;
  headers: Map<string, string>;
  ended: boolean;
  body: string;
  setHeader(name: string, value: string): void;
  flushHeaders(): void;
  write(chunk: string | Buffer): boolean;
  end(chunk?: string | Buffer): void;
};

function makeResponse(): CaptureResponse {
  const chunks: string[] = [];
  return {
    statusCode: 0,
    headers: new Map<string, string>(),
    ended: false,
    get body() { return chunks.join(""); },
    setHeader(name, value) { this.headers.set(name.toLowerCase(), String(value)); },
    flushHeaders() {},
    write(chunk) { chunks.push(String(chunk)); return true; },
    end(chunk) {
      if (chunk != null) chunks.push(String(chunk));
      this.ended = true;
    },
  };
}

function makeRequest(content: unknown, stream: boolean): any {
  const body = JSON.stringify({
    model: "object-stringification-model",
    messages: [{ role: "user", content }],
    stream,
  });
  const req = Readable.from([Buffer.from(body)]) as any;
  req.method = "POST";
  req.url = "/v1/chat/completions";
  req.headers = {
    host: "fixture.invalid",
    "content-type": "application/json",
    "x-hermes-session-id": "object-stringification-session",
  };
  return req;
}

function makeGateway(calls: Array<Record<string, unknown>>): Gateway {
  return {
    async *submitTurn(input: GatewaySubmitTurnInput): AsyncGenerator<GatewayEvent> {
      calls.push({
        keys: Object.keys(input).sort(),
        sessionKey: input.sessionKey,
        channelKey: input.channelKey,
        message: input.message,
        attachments: input.attachments ?? null,
      });
      yield { type: "assistant_text_delta", text: "fixture-reply" };
      yield {
        type: "turn_completed",
        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
        finishReason: "completed",
      };
    },
  } as unknown as Gateway;
}

function summarizeBody(response: CaptureResponse): Record<string, unknown> {
  let parsed: any = null;
  try { parsed = JSON.parse(response.body); } catch { /* streaming body */ }
  return {
    responseObject: parsed?.object ?? null,
    assistantContent: parsed?.choices?.[0]?.message?.content ?? null,
    hasSseData: response.body.includes("data: "),
    hasDone: response.body.includes("data: [DONE]"),
  };
}

async function runCase(name: string, content: unknown, stream: boolean): Promise<Record<string, unknown>> {
  const calls: Array<Record<string, unknown>> = [];
  const mapper = new ApiServerSessionMapper({ activeByChatId: {} }, () => "object-stringification-uuid");
  const channel = new ApiServerChannel({ mapper, modelName: "object-stringification-model" });
  (channel as any).gateway = makeGateway(calls);
  const response = makeResponse();
  await (channel as any).handleRequest(makeRequest(content, stream), response);
  return {
    name,
    stream,
    status: response.statusCode,
    contentType: response.headers.get("content-type") ?? null,
    response: summarizeBody(response),
    gatewayCalls: calls,
    mapper: mapper.snapshot(),
  };
}

const cases = [
  { name: "arbitrary-object", content: { kind: "fixture-object", value: 7 } },
  { name: "object-text-shape", content: { type: "text", text: "fixture-object-text" } },
];

const results: Array<Record<string, unknown>> = [];
for (const item of cases) {
  results.push(await runCase(item.name, item.content, false));
  results.push(await runCase(item.name, item.content, true));
}

console.log(JSON.stringify({
  fixture: "api-server-content-object-stringification-witness",
  transport: "in-memory IncomingMessage/ServerResponse equivalent",
  endpoint: "POST /v1/chat/completions",
  gatewayOracle: "capture exact normalized message and input keys",
  results,
}, null, 2));