agent.ts

// Any message starts a five-second countdown. No model or external API calls.
export default async function agent({ request }: { request: Request }) {
	const { stream = false } = (await request.json()) as { stream?: boolean };
	const response = {
		id: `resp_${crypto.randomUUID()}`,
		object: "response",
		created_at: Math.floor(Date.now() / 1000),
		model: "voodoohop/pollinations-timer-agent",
		status: "in_progress",
		error: null,
		incomplete_details: null,
		output: [] as unknown[],
		usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
	};
	const part = { type: "output_text", text: "", annotations: [] };
	const message = {
		id: `msg_${crypto.randomUUID()}`,
		type: "message",
		status: "in_progress",
		role: "assistant",
		content: [part],
	};
	const finish = () => {
		message.status = "completed";
		response.status = "completed";
		response.output = [message];
	};

	if (!stream) {
		await new Promise((resolve) => setTimeout(resolve, 5_000));
		part.text = "5…\n4…\n3…\n2…\n1…\nDone!\n";
		finish();
		return Response.json(response);
	}

	let timer: ReturnType<typeof setInterval>;
	const body = new ReadableStream<Uint8Array>({
		start(controller) {
			const encoder = new TextEncoder();
			let sequence = 0;
			const emit = (type: string, fields: Record<string, unknown>) => {
				const event = { type, sequence_number: sequence++, ...fields };
				controller.enqueue(
					encoder.encode(`event: ${type}\ndata: ${JSON.stringify(event)}\n\n`),
				);
			};
			const indices = {
				item_id: message.id,
				output_index: 0,
				content_index: 0,
			};
			const tick = (delta: string) => {
				part.text += delta;
				emit("response.output_text.delta", { ...indices, delta, logprobs: [] });
			};

			emit("response.created", { response });
			emit("response.in_progress", { response });
			emit("response.output_item.added", {
				output_index: 0,
				item: { ...message, content: [] },
			});
			emit("response.content_part.added", { ...indices, part });
			tick("5…\n");
			let remaining = 5;
			timer = setInterval(() => {
				remaining--;
				tick(remaining > 0 ? `${remaining}…\n` : "Done!\n");
				if (remaining > 0) return;
				clearInterval(timer);
				finish();
				emit("response.output_text.done", {
					...indices,
					text: part.text,
					logprobs: [],
				});
				emit("response.content_part.done", { ...indices, part });
				emit("response.output_item.done", { output_index: 0, item: message });
				emit("response.completed", { response });
				controller.close();
			}, 1_000);
		},
		cancel() {
			clearInterval(timer);
		},
	});
	return new Response(body, {
		headers: {
			"content-type": "text/event-stream",
			"cache-control": "no-cache",
		},
	});
}