chore: import upstream snapshot with attribution

tests/unit/t27-github-copilot-response-format.test.ts

@@ -0,0 +1,233 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+const { GithubExecutor } = await import("../../open-sse/executors/github.ts");
+const { BaseExecutor } = await import("../../open-sse/executors/base.ts");
+
+function streamFromChunks(chunks) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk));
+      }
+      controller.close();
+    },
+  });
+}
+
+const originalFetch = globalThis.fetch;
+
+test.afterEach(async () => {
+  globalThis.fetch = originalFetch;
+});
+
+test.after(() => {
+  globalThis.fetch = originalFetch;
+});
+
+test("T27: Claude + response_format=json_object injects system instruction and strips response_format field", () => {
+  const executor = new GithubExecutor();
+  const request = {
+    messages: [{ role: "user", content: "return json" }],
+    response_format: { type: "json_object" },
+  };
+
+  const transformed = executor.transformRequest("claude-sonnet-4.5", request, false, {});
+
+  assert.equal(transformed.response_format, undefined);
+  assert.equal(transformed.messages[0].role, "system");
+  assert.match(
+    transformed.messages[0].content,
+    /Respond only with valid JSON\. Do not include any text/i
+  );
+});
+
+test("T27: non-Claude models keep response_format untouched", () => {
+  const executor = new GithubExecutor();
+  const request = {
+    messages: [{ role: "user", content: "hello" }],
+    response_format: { type: "json_object" },
+  };
+
+  const transformed = executor.transformRequest("gpt-4o", request, false, {});
+  assert.deepEqual(transformed.response_format, { type: "json_object" });
+});
+
+test("T27: GitHub executor preserves SSE frames and only materializes non-streaming bodies", async () => {
+  const executor = new GithubExecutor();
+  const originalExecute = BaseExecutor.prototype.execute;
+
+  BaseExecutor.prototype.execute = async () => ({
+    response: new Response(
+      streamFromChunks(['data: {"delta":"hello"}\n\n', "data: [DONE]\n\n", "data: tail\n\n"]),
+      {
+        status: 200,
+        headers: { "content-type": "text/event-stream" },
+      }
+    ),
+    url: "https://api.githubcopilot.com/chat/completions",
+    headers: {},
+    transformedBody: {},
+  });
+
+  try {
+    const streamingResult = await executor.execute({
+      model: "claude-sonnet-4.5",
+      body: { messages: [] },
+      stream: true,
+      credentials: { accessToken: "token" },
+    });
+    const streamingText = await streamingResult.response.text();
+    assert.equal(streamingText.includes("data: [DONE]"), true);
+    assert.equal(streamingText.includes("data: tail"), true);
+
+    const nonStreamingResult = await executor.execute({
+      model: "claude-sonnet-4.5",
+      body: { messages: [] },
+      stream: false,
+      credentials: { accessToken: "token" },
+    });
+    const nonStreamingText = await nonStreamingResult.response.text();
+    assert.equal(nonStreamingText.includes("data: [DONE]"), true);
+  } finally {
+    BaseExecutor.prototype.execute = originalExecute;
+  }
+});
+
+test("T27: streaming error responses keep their original body readable", async () => {
+  const executor = new GithubExecutor();
+  const originalExecute = BaseExecutor.prototype.execute;
+
+  BaseExecutor.prototype.execute = async () => ({
+    response: new Response("IDE token expired: unauthorized: token expired\n", {
+      status: 401,
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    }),
+    url: "https://api.githubcopilot.com/chat/completions",
+    headers: {},
+    transformedBody: {},
+  });
+
+  try {
+    const result = await executor.execute({
+      model: "claude-sonnet-4.5",
+      body: { messages: [] },
+      stream: true,
+      credentials: { accessToken: "token" },
+    });
+
+    assert.equal(result.response.status, 401);
+    assert.equal(await result.response.text(), "IDE token expired: unauthorized: token expired\n");
+  } finally {
+    BaseExecutor.prototype.execute = originalExecute;
+  }
+});
+
+test("T27: requests use copilotToken from providerSpecificData when available", async () => {
+  globalThis.fetch = async (_url, init: RequestInit = {}) => {
+    assert.equal((init.headers as Record<string, string>).Authorization, "Bearer copilot_test");
+    return new Response(
+      JSON.stringify({
+        choices: [
+          { index: 0, message: { role: "assistant", content: "OK" }, finish_reason: "stop" },
+        ],
+      }),
+      {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }
+    );
+  };
+
+  const executor = new GithubExecutor();
+  const result = await executor.execute({
+    model: "gemini-3.1-pro-preview",
+    body: { messages: [{ role: "user", content: "Ping" }], stream: false },
+    stream: false,
+    credentials: {
+      accessToken: "ghu_test",
+      providerSpecificData: {
+        copilotToken: "copilot_test",
+      },
+    },
+  });
+
+  assert.equal(result.response.status, 200);
+  assert.match(await result.response.text(), /OK/);
+});
+
+test("T27: non-stream execute materializes provider responses before returning", async () => {
+  const executor = new GithubExecutor();
+  const originalExecute = BaseExecutor.prototype.execute;
+
+  class WeirdResponse {
+    _body: string;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    bodyUsed: boolean;
+    body: Record<string, unknown>;
+
+    constructor(body: string, init: ResponseInit = {}) {
+      this._body = body;
+      this.status = init.status || 200;
+      this.statusText = init.statusText || "OK";
+      this.headers = new Headers(init.headers || {});
+      this.bodyUsed = false;
+      this.body = {};
+    }
+
+    async text() {
+      if (this.bodyUsed) {
+        throw new TypeError("Response body is already used");
+      }
+      this.bodyUsed = true;
+      return this._body;
+    }
+  }
+
+  BaseExecutor.prototype.execute = async () => ({
+    response: new WeirdResponse(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    }),
+    url: "https://api.githubcopilot.com/chat/completions",
+    headers: {},
+    transformedBody: {},
+  });
+
+  try {
+    const result = await executor.execute({
+      model: "gemini-3.1-pro-preview",
+      body: { messages: [{ role: "user", content: "Ping" }], stream: false },
+      stream: false,
+      credentials: {
+        accessToken: "ghu_test",
+        providerSpecificData: {
+          copilotToken: "copilot_test",
+        },
+      },
+    });
+
+    assert.equal(result.response.constructor.name, "Response");
+    assert.equal(await result.response.text(), JSON.stringify({ ok: true }));
+  } finally {
+    BaseExecutor.prototype.execute = originalExecute;
+  }
+});
+
+test("T27: needsRefresh respects providerSpecificData copilot token metadata", () => {
+  const executor = new GithubExecutor();
+  const expiresAt = Math.floor(Date.now() / 1000) + 3600;
+
+  assert.equal(
+    executor.needsRefresh({
+      accessToken: "ghu_test",
+      providerSpecificData: {
+        copilotToken: "copilot_test",
+        copilotTokenExpiresAt: expiresAt,
+      },
+    }),
+    false
+  );
+});