// sdk-run.ts
import { createAgentSession } from "@earendil-works/pi-coding-agent";

const { session } = await createAgentSession();

// 订阅必须早于 prompt：否则快速完成的运行可能在你订阅之前就把事件发完了
const unsubscribe = session.subscribe((event) => {
	// 只取 text_delta：thinking 和 toolcall 是另两类增量，混在一起会拼出乱码
	if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
		process.stdout.write(event.assistantMessageEvent.delta);
	}
});

try {
	await session.prompt("这个仓库的测试怎么跑？");
	console.log(session.getLastAssistantText());
} finally {
	// 释放顺序：先退订再 dispose，避免释放之后再收到残留回调
	unsubscribe();
	session.dispose();
}

// 插到当前助手轮次之后
await session.steer("先看 README.md");

// 等智能体把手上的活做完
await session.followUp("做完之后再总结一下改动");

// 停掉当前操作，并等待会话进入空闲
await session.abort();

// 只等待，不取消
await session.waitForIdle();

// runtime.ts
import {
	type CreateAgentSessionRuntimeFactory,
	createAgentSessionFromServices,
	createAgentSessionRuntime,
	createAgentSessionServices,
	getAgentDir,
	SessionManager,
} from "@earendil-works/pi-coding-agent";

// 运行时工厂：每建一个会话都要为目标 cwd 重建服务，扩展工厂也要一起传进去
const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
	const services = await createAgentSessionServices({ cwd });
	return {
		...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
		services,
		diagnostics: services.diagnostics,
	};
};

const runtime = await createAgentSessionRuntime(createRuntime, {
	cwd: process.cwd(),
	agentDir: getAgentDir(),
	sessionManager: SessionManager.create(process.cwd()),
});

// 当前订阅的退订函数。运行时替换会话后旧订阅属于旧对象，必须重新绑定
let unsubscribe: (() => void) | undefined;

async function bindSession() {
	// 先退订旧的：否则同一个回调里会同时收到新旧两个会话的事件
	unsubscribe?.();
	const session = runtime.session;
	// SDK 不自动 bindExtensions：MCP 扩展在 session_start 才连服务器，这里必须手动触发
	await session.bindExtensions({});
	unsubscribe = session.subscribe((event) => {
		if (event.type === "queue_update") {
			console.log("排队中：", event.steering.length + event.followUp.length);
		}
	});
	return session;
}

let session = await bindSession();

try {
	await runtime.newSession();
	session = await bindSession();   // 重新绑定，否则收不到新会话的事件
	await session.prompt("新会话里的一句问候");
} finally {
	unsubscribe?.();
	await runtime.dispose();
}

# 启动 RPC 模式的 Pi 子进程：之后从 stdin 发命令，从 stdout 读 JSONL 响应与事件
# --no-session 用内存会话，不落盘；不加它会把会话写进 ~/.pi/agent/sessions/
pi --mode rpc --no-session

{"id":"req-1","type":"get_state"}
{"id":"req-1","type":"response","command":"get_state","success":true,"data":{"...":"..."}}

// rpc-run.ts
import { spawn } from "node:child_process";

const child = spawn("pi", ["--mode", "rpc", "--no-session"], {
	stdio: ["pipe", "pipe", "pipe"],
});

// 诊断信息走 stderr，不污染 stdout 的协议流
child.stderr.pipe(process.stderr);

type JsonRecord = Record<string, any>;

let buffer = "";
let settled: (() => void) | undefined;

// 手动按 LF 分帧：readline 会把 U+2028 / U+2029 也当边界，而它们在 JSON 字符串里是合法的
child.stdout.on("data", (chunk: Buffer) => {
	buffer += chunk.toString("utf8");
	let index: number;
	while ((index = buffer.indexOf("\n")) !== -1) {
		const line = buffer.slice(0, index).replace(/\r$/, "");
		buffer = buffer.slice(index + 1);
		if (line.length === 0) continue;
		handleRecord(JSON.parse(line) as JsonRecord);
	}
});

function send(command: JsonRecord) {
	child.stdin.write(`${JSON.stringify(command)}\n`);
}

function handleRecord(record: JsonRecord) {
	if (record.type === "response") {
		console.error(`[响应] ${record.command} success=${record.success}`);
		return;
	}
	if (record.type === "message_update" && record.assistantMessageEvent?.type === "text_delta") {
		process.stdout.write(record.assistantMessageEvent.delta);
		return;
	}
	if (record.type === "tool_execution_start") {
		console.error(`[工具] ${record.toolName}`);
		return;
	}
	if (record.type === "agent_settled") {
		settled?.();
	}
}

try {
	// 先装好等待，再发命令：否则快速完成时可能漏掉 agent_settled
	const done = new Promise<void>((resolve) => {
		settled = resolve;
	});
	send({ id: "req-1", type: "prompt", message: "这个仓库的测试怎么跑？" });

	// 等 agent_settled 再收尾：agent_end 之后还可能有重试或排队工作
	await done;
} finally {
	// 关闭 stdin 请求有序退出：Pi 会先释放活动运行时再退出
	child.stdin.end();
	await new Promise<void>((resolve) => child.once("exit", () => resolve()));
}

import { RpcClient } from "@earendil-works/pi-coding-agent";

// cliPath 指向一个可运行的 Pi CLI；默认是 "dist/cli.js"
const client = new RpcClient({
	cliPath: "/opt/pi/dist/cli.js",
	args: ["--no-session"],
});

// 先装监听器再发 prompt：事件在 start() 之后就开始流了
const unsubscribe = client.onEvent((event) => {
	if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
		process.stdout.write(event.assistantMessageEvent.delta);
	}
});

try {
	// start() 才真正拉起 Pi 子进程，之后才有事件
	await client.start();
	// promptAndWait 内部自己保证"先装监听器再发 prompt"，不会漏掉快速完成
	await client.promptAndWait("这个仓库的测试怎么跑？");
} finally {
	unsubscribe();
	// stop() 会关闭子进程 stdin，让 Pi 走有序退出路径
	await client.stop();
}