Keep sessionStart hook additionalContext after compaction #5225

// Shows whether sessionStart additionalContext reaches the model after compaction.
//
// Usage:
//   COPILOT_SDK=/path/to/copilot-sdk/index.js \
//   COPILOT_RUNTIME=/path/to/copilot \
//   node repro-sessionstart-compaction.mjs
//
// COPILOT_RUNTIME is a runtime binary or the index.js of the @github/copilot package.
// The session talks to a local mock model server, so the script makes no real model calls.
// It writes only to a temporary COPILOT_HOME, which it deletes at the end.

import fs from "node:fs";
import http from "node:http";
import os from "node:os";
import path from "node:path";
import { pathToFileURL } from "node:url";

const { COPILOT_SDK, COPILOT_RUNTIME } = process.env;
if (!COPILOT_SDK || !COPILOT_RUNTIME) {
	console.error("Set COPILOT_SDK to the SDK's index.js and COPILOT_RUNTIME to the copilot runtime.");
	process.exit(2);
}
const { CopilotClient, RuntimeConnection, approveAll } = await import(pathToFileURL(COPILOT_SDK).href);

const HOOK_MARKER = "HOOK-MARKER-7Q2";
const INSTRUCTIONS_MARKER = "INSTRUCTIONS-MARKER-4K9";
const SUMMARY = [
	"<overview>A short test conversation.</overview>",
	"<history>1. The user sent a test message.</history>",
	"<work_done>None.</work_done>",
	"<technical_details>None.</technical_details>",
	"<important_files>None.</important_files>",
	"<next_steps>Wait for the next message.</next_steps>",
	"<checkpoint_title>Test checkpoint</checkpoint_title>",
].join("\n");

const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sessionstart-compaction-"));
const home = path.join(tmp, "home");
const work = path.join(tmp, "work");
fs.mkdirSync(home);
fs.mkdirSync(work);
fs.writeFileSync(path.join(home, "copilot-instructions.md"), `${INSTRUCTIONS_MARKER}\n`);

// A mock OpenAI-compatible server that records which markers each chat request contains.
const requests = [];
let step = "setup";
const server = http.createServer((req, res) => {
	let raw = "";
	req.on("data", (chunk) => (raw += chunk));
	req.on("end", () => {
		if (req.method !== "POST") {
			res.writeHead(200, { "Content-Type": "application/json" });
			res.end(JSON.stringify({ object: "list", data: [{ id: "mock-model", object: "model", owned_by: "mock" }] }));
			return;
		}
		const body = JSON.parse(raw);
		const messages = JSON.stringify(body.messages);
		const isSummary = messages.includes("Please create a detailed summary");
		requests.push({
			request: isSummary ? "compaction summary request" : step,
			"sessionStart context": messages.includes(HOOK_MARKER) ? "yes" : "no",
			"copilot-instructions.md": messages.includes(INSTRUCTIONS_MARKER) ? "yes" : "no",
		});
		const text = isSummary ? SUMMARY : "OK";
		const created = Math.floor(Date.now() / 1000);
		const usage = { prompt_tokens: 1000, completion_tokens: 20, total_tokens: 1020 };
		if (!body.stream) {
			res.writeHead(200, { "Content-Type": "application/json" });
			res.end(JSON.stringify({ id: "mock", object: "chat.completion", created, model: "mock-model", choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: "stop" }], usage }));
			return;
		}
		res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
		const send = (chunk) => res.write(`data: ${JSON.stringify(chunk)}\n\n`);
		send({ id: "mock", object: "chat.completion.chunk", created, model: "mock-model", choices: [{ index: 0, delta: { role: "assistant", content: text }, finish_reason: null }] });
		send({ id: "mock", object: "chat.completion.chunk", created, model: "mock-model", choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage });
		res.end("data: [DONE]\n\n");
	});
});
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
const { port } = server.address();

const sources = [];
const sessionConfig = {
	model: "mock-model",
	provider: { type: "openai", wireApi: "completions", baseUrl: `http://127.0.0.1:${port}/v1`, apiKey: "mock", maxPromptTokens: 120000, maxOutputTokens: 4096 },
	onPermissionRequest: approveAll,
	workingDirectory: work,
	hooks: {
		onSessionStart: async (input) => {
			sources.push(input.source);
			return { additionalContext: `${HOOK_MARKER} (source: ${input.source})` };
		},
	},
};
const newClient = () =>
	new CopilotClient({
		connection: RuntimeConnection.forStdio({ path: COPILOT_RUNTIME }),
		baseDirectory: home,
		workingDirectory: work,
		logLevel: "error",
	});

let client = newClient();
try {
	await client.start();
	const session = await client.createSession(sessionConfig);
	step = "turn 1";
	await session.sendAndWait({ prompt: "First message." }, 60000);
	step = "manual compaction";
	await session.rpc.history.compact({ trigger: "manual" });
	step = "turn 2, after compaction";
	await session.sendAndWait({ prompt: "Second message." }, 60000);
	await session.disconnect();
	await client.stop();

	client = newClient();
	await client.start();
	const resumed = await client.resumeSession(session.sessionId, sessionConfig);
	step = "turn 3, after resume";
	await resumed.sendAndWait({ prompt: "Third message." }, 60000);
	await resumed.disconnect();
} finally {
	await client.stop().catch(() => {});
	server.close();
	fs.rmSync(tmp, { recursive: true, force: true });
}

console.log(`sessionStart ran with source: ${sources.join(", ")}`);
console.table(requests);
process.exit(0);