Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/pipi/__acceptance__/provider.ts

Raw
import { setTimeout as delay } from "node:timers/promises";
import {
	contentText,
	createFauxCore,
	fauxAssistantMessage,
	fauxToolCall,
	type JsonObject,
	type JsonValue,
} from "@earendil-works/pi-ai";
import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";

interface Instruction {
	kind?: string;
	text?: string;
	value?: JsonValue;
	invalid?: JsonValue;
	tool?: string;
	args?: JsonObject;
	request?: JsonObject;
	calls?: JsonObject[];
	script?: string;
	values?: JsonValue[];
}
export default function provider(pi: ExtensionAPI): void {
	const core = createFauxCore({
		tokensPerSecond: process.env["PIPI_E2E_STREAM"] ? 80 : 100000,
		tokenSize: process.env["PIPI_E2E_STREAM"]
			? { min: 1, max: 3 }
			: { min: 128, max: 256 },
		api: "openai",
		provider: "pipi-test",
		models: [
			{ id: "parent", name: "Acceptance parent" },
			{ id: "alternate", name: "Acceptance alternate", reasoning: true },
		],
	});
	core.setResponses(
		Array.from({ length: 128 }, () => async (context, options) => {
			const index = context.messages.findLastIndex(
				(message) => message.role === "user",
			);
			const message = context.messages[index];
			const text =
				message && "content" in message ? contentText(message.content) : "";
			const match = /PIPI_(PARENT|CHILD) (\{[\s\S]*\})/u.exec(text);
			if (!match) return fauxAssistantMessage("READY");
			const request = JSON.parse(match[2] ?? "{}") as Instruction;
			const recent = context.messages.slice(index + 1);
			const results = recent.filter((entry) => entry.role === "toolResult");
			if (match[1] === "PARENT") {
				if (results.length) return fauxAssistantMessage("PARENT_OK");
				if (request.script)
					return fauxAssistantMessage(
						fauxToolCall("codemode", { code: request.script }),
					);
				return fauxAssistantMessage(
					(request.calls ?? []).map((args, i) =>
						fauxToolCall("pipi", args, { id: `call-${i}` }),
					),
				);
			}
			switch (request.kind) {
				case "submit":
					return fauxAssistantMessage(
						fauxToolCall("pipi_output", { output: request.value ?? null }),
					);
				case "correct":
					return fauxAssistantMessage(
						fauxToolCall("pipi_output", {
							output: results.some((entry) => entry.isError)
								? (request.value ?? null)
								: (request.invalid ?? null),
						}),
					);
				case "last":
					return fauxAssistantMessage(
						(request.values ?? []).map((value, i) =>
							fauxToolCall(
								"pipi_output",
								{ output: value },
								{ id: `submit-${i}` },
							),
						),
					);
				case "post-error":
					return results.length
						? fauxAssistantMessage("", {
								stopReason: "error",
								errorMessage: "Intentional failure after submission",
							})
						: fauxAssistantMessage([
								fauxToolCall("pipi_output", { output: request.value ?? null }),
								fauxToolCall("read", { path: "nonexistent.txt" }),
							]);
				case "forget":
					return fauxAssistantMessage("No submission this turn");
				case "error":
					return fauxAssistantMessage("", {
						stopReason: "error",
						errorMessage: "Intentional provider failure",
					});
				case "wait":
					await delay(
						30_000,
						undefined,
						options?.signal ? { signal: options.signal } : {},
					);
					return fauxAssistantMessage("Late response");
				case "nested":
					return results.length
						? fauxAssistantMessage("Nested complete")
						: fauxAssistantMessage(fauxToolCall("pipi", request.request ?? {}));
				case "tool":
					return results.length
						? fauxAssistantMessage(
								results.map((entry) => contentText(entry.content)).join("\n"),
							)
						: fauxAssistantMessage(
								fauxToolCall(request.tool ?? "read", request.args ?? {}),
							);
				case "stream":
					await delay(
						300,
						undefined,
						options?.signal ? { signal: options.signal } : {},
					);
					return fauxAssistantMessage(
						"STREAM_CHILD " + "streamed evidence ".repeat(20),
					);
				case "history":
					return fauxAssistantMessage(
						context.messages.some(
							(entry) =>
								entry.role === "user" &&
								contentText(entry.content).includes("remember-7391"),
						)
							? "resumed child answer: remember-7391"
							: "HISTORY_MISSING",
					);
				default:
					return fauxAssistantMessage(request.text ?? "native child answer");
			}
		}),
	);
	pi.registerProvider("pipi-test", {
		api: "openai",
		baseUrl: "https://offline.invalid",
		apiKey: "offline",
		streamSimple: core.streamSimple,
		models: core.models.map((model) => ({
			id: model.id,
			name: model.name,
			reasoning: model.reasoning,
			input: model.input,
			cost: model.cost,
			contextWindow: model.contextWindow,
			maxTokens: model.maxTokens,
		})),
	});
}