pi-roundtable 0.1.0

package/src/core/modules/delegation/delegator.ts

@@ -0,0 +1,191 @@
+import type {
+	DispatchThread,
+	DispatchThreads,
+} from "../../discord/dispatch-threads.ts";
+import type { ChannelKey } from "../../domain/conversation.ts";
+import { DelegationError } from "../../domain/errors.ts";
+import { messages } from "../../i18n/index.ts";
+import type { Logger } from "../../log.ts";
+import type { Tier } from "../../speakers.ts";
+import { timeZone } from "../../time.ts";
+
+export type DelegationMode = "owner" | "party";
+
+export interface DelegationJob {
+	id: number;
+	/** Where the report comes back as a turn. */
+	channel: ChannelKey;
+	/** The channel of the owner's turn that started it, which hosts its thread; party jobs have none. */
+	origin?: ChannelKey;
+	mode: DelegationMode;
+	/** Who asked; a party report is answered as this person's turn. */
+	author: { id: string; name: string; tier?: Tier };
+	title: string;
+	task: string;
+	startedAt: Date;
+	/** Where its report is posted, once opened; absent where no thread could open. */
+	thread?: DispatchThread;
+}
+
+export type DelegationOutcome =
+	| { ok: true; report: string }
+	| { ok: false; error: string };
+
+export interface DelegationWorker {
+	run(task: string, signal: AbortSignal): Promise<string>;
+}
+
+export interface DelegatorOptions {
+	worker: DelegationWorker;
+	/** Posts the finished job back in its channel; never rejects. */
+	deliver: (job: DelegationJob, outcome: DelegationOutcome) => Promise<void>;
+	/** Each job's thread in its origin; without it every job reports in its channel only. */
+	threads?: Pick<DispatchThreads, "open">;
+	logger: Logger;
+	timeoutMs?: number;
+}
+
+const MAX_TASK_CHARS = 4_000;
+/** Jobs one channel may have running at once. */
+const RUNNING_LIMIT: Readonly<Record<DelegationMode, number>> = {
+	owner: 3,
+	party: 2,
+};
+
+/**
+ * Runs delegated tasks in the background and hands each result back to its channel. Jobs live
+ * in memory: a restart drops the running ones, and the channel never hears back from them.
+ */
+export class Delegator {
+	readonly #options: DelegatorOptions;
+	readonly #running = new Map<
+		number,
+		{ job: DelegationJob; done: Promise<void> }
+	>();
+	#nextId = 1;
+
+	constructor(options: DelegatorOptions) {
+		this.#options = options;
+	}
+
+	/** Starts a job and returns at once; throws DelegationError on bad input or a full channel. */
+	start(
+		request: Omit<DelegationJob, "id" | "startedAt" | "thread">,
+	): DelegationJob {
+		const title = request.title.trim();
+		const task = request.task.trim();
+		if (!title || !task)
+			throw new DelegationError("title and task are required");
+		if (task.length > MAX_TASK_CHARS)
+			throw new DelegationError(
+				`the task is ${task.length} characters; keep it within ${MAX_TASK_CHARS}`,
+			);
+		const busy = [...this.#running.values()].filter(
+			({ job }) => job.channel === request.channel,
+		).length;
+		const limit = RUNNING_LIMIT[request.mode];
+		if (busy >= limit)
+			throw new DelegationError(
+				`this channel already has ${busy} delegated tasks running; wait for one to report back`,
+			);
+		const job: DelegationJob = {
+			...request,
+			title,
+			task,
+			id: this.#nextId++,
+			startedAt: new Date(),
+		};
+		const done = this.#run(job).finally(() => this.#running.delete(job.id));
+		this.#running.set(job.id, { job, done });
+		return job;
+	}
+
+	/** The channel of each job still running, one entry per job. */
+	runningChannels(): ChannelKey[] {
+		return [...this.#running.values()].map(({ job }) => job.channel);
+	}
+
+	/** Resolves once every started job has reported. */
+	async idle(): Promise<void> {
+		await Promise.all([...this.#running.values()].map(({ done }) => done));
+	}
+
+	async #run(job: DelegationJob): Promise<void> {
+		const {
+			worker,
+			deliver,
+			threads,
+			logger,
+			timeoutMs = 20 * 60_000,
+		} = this.#options;
+		logger.info(
+			{ job: job.id, channel: job.channel, mode: job.mode },
+			"delegated task started",
+		);
+		const thread = await threads?.open(
+			job.origin,
+			job.title,
+			messages().delegationTask(job.task),
+		);
+		if (thread) job.thread = thread;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		let outcome: DelegationOutcome;
+		try {
+			outcome = {
+				ok: true,
+				report: await worker.run(job.task, controller.signal),
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		} finally {
+			clearTimeout(timer);
+		}
+		logger.info(
+			{ job: job.id, ok: outcome.ok, ms: Date.now() - job.startedAt.getTime() },
+			"delegated task finished",
+		);
+		await thread?.close(
+			outcome.ok
+				? messages().delegationDone(outcome.report)
+				: messages().delegationFailed(outcome.error),
+		);
+		await deliver(job, outcome).catch((error: unknown) =>
+			logger.error({ job: job.id, err: error }, "delegated report not posted"),
+		);
+	}
+}
+
+/** What the asking agent receives when its delegated task reports back. */
+export function delegatedTurnText(
+	job: DelegationJob,
+	outcome: DelegationOutcome,
+	localTime: string,
+): string {
+	const head = [
+		`## Delegated task #${job.id}: ${job.title}`,
+		...(job.thread
+			? [
+					`Its task and report are in the thread ${job.thread.mention}, now archived; link it when useful.`,
+				]
+			: []),
+	].join("\n");
+	if (!outcome.ok)
+		return [
+			head,
+			`The task handed to the worker model at ${localTime} ${messages().zoneTime(timeZone())} failed: ${outcome.error}. Nobody wrote a new message: tell ${job.author.name} it failed and what you can do instead.`,
+		].join("\n");
+	return [
+		head,
+		`The task handed to the worker model at ${localTime} ${messages().zoneTime(timeZone())} has reported back. Nobody wrote a new message: answer ${job.author.name} with it in your own words, keeping the source links.`,
+		"",
+		"### Task",
+		job.task,
+		"",
+		"### Report",
+		outcome.report,
+	].join("\n");
+}

package/src/core/modules/delegation/sol-worker.ts

@@ -0,0 +1,78 @@
+import { mkdirSync } from "node:fs";
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	type ModelRuntime,
+	SessionManager,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import {
+	formatModelRef,
+	type ModelRef,
+	type ThinkingLevel,
+} from "../../models.ts";
+import { runWorkerTask } from "../../runtime/worker-task.ts";
+import { packageDir } from "../../shared/package-dir.ts";
+import { profileToolsExtension } from "../../shared/profile-tools.ts";
+
+const WEB_TOOLS = ["web_search", "fetch_content", "get_search_content"];
+
+const WORKER_PROMPT =
+	"You are a research worker. Another agent handed you the task below and will pass your report on. Do it with web search and page reading, preferring primary sources. Report in the task's language, self-contained, with a source link for each claim, and say what you could not verify.";
+
+export interface SolWorkerOptions {
+	/** Shared with the rest of the host, so the Codex login refreshes in one place. */
+	modelRuntime: ModelRuntime;
+	agentDir: string;
+	workDir: string;
+	model: ModelRef;
+	thinking: ThinkingLevel;
+}
+
+/** Runs one task in a fresh, unsaved session that can only search and read the web. */
+export class SolWorker {
+	readonly #options: SolWorkerOptions;
+	readonly #webAccessPath: string;
+
+	constructor(options: SolWorkerOptions) {
+		this.#options = options;
+		this.#webAccessPath = packageDir("pi-web-access");
+		mkdirSync(options.workDir, { recursive: true });
+	}
+
+	async run(task: string, signal: AbortSignal): Promise<string> {
+		const { modelRuntime, agentDir, workDir, model, thinking } = this.#options;
+		const resourceLoader = new DefaultResourceLoader({
+			cwd: workDir,
+			agentDir,
+			noExtensions: true,
+			noSkills: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			noContextFiles: true,
+			additionalExtensionPaths: [this.#webAccessPath],
+			extensionFactories: [
+				{ name: "web-only", factory: profileToolsExtension(() => WEB_TOOLS) },
+			],
+			appendSystemPrompt: [WORKER_PROMPT],
+		});
+		await resourceLoader.reload();
+		const { session } = await createAgentSession({
+			cwd: workDir,
+			agentDir,
+			thinkingLevel: thinking,
+			modelRuntime,
+			resourceLoader,
+			sessionManager: SessionManager.inMemory(workDir),
+			settingsManager: SettingsManager.inMemory({}),
+			noTools: "builtin",
+		});
+		return runWorkerTask(session, {
+			modelRuntime,
+			model: formatModelRef(model),
+			task,
+			signal,
+			aborted: "the worker ran out of time",
+		});
+	}
+}

package/src/core/modules/discord-admin/discord-admin.ts

@@ -0,0 +1,288 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import { type TObject, Type } from "typebox";
+import {
+	CHANNEL_TOOLS,
+	ChannelToolError,
+} from "../../discord/channel-operations.ts";
+import { assistantName } from "../../i18n/index.ts";
+import {
+	type OwnerIdentity,
+	type OwnerWords,
+	ownerWords,
+} from "../../identity.ts";
+import { textToolsExtension } from "../../runtime/text-tools.ts";
+
+const id = Type.String({ pattern: "^\\d{1,20}$" });
+const guild = { guildId: id };
+const member = { guildId: id, userId: id };
+const reason = Type.Optional(
+	Type.String({
+		maxLength: 400,
+		description: "Shown in the server's audit log.",
+	}),
+);
+const roleFields = {
+	name: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+	color: Type.Optional(
+		Type.String({ pattern: "^#[0-9a-fA-F]{6}$", description: "#rrggbb" }),
+	),
+	hoist: Type.Optional(
+		Type.Boolean({ description: "Show members separately in the list." }),
+	),
+	mentionable: Type.Optional(Type.Boolean()),
+	permissions: Type.Optional(
+		Type.Array(Type.String(), {
+			maxItems: 60,
+			description:
+				"Every permission the role grants, as discord.js PermissionFlagsBits names.",
+		}),
+	),
+};
+const strict = { additionalProperties: false } as const;
+const autoArchive = Type.Union(
+	[60, 1440, 4320, 10080].map((v) => Type.Literal(v)),
+	{
+		description: "Minutes of inactivity before the thread archives.",
+	},
+);
+
+interface ServerTool {
+	label: string;
+	/** The tool's description, naming the owner in `o`'s words. */
+	describe(o: OwnerWords): string;
+	parameters: TObject;
+}
+
+/** Server-level tools only the owner's agent has; channel tools reuse the outside-agent set. */
+export const SERVER_TOOLS: Record<string, ServerTool> = {
+	discord_list_servers: {
+		label: "List Discord servers",
+		describe: (o) =>
+			`List the Discord servers that ${o.name} and ${assistantName()} share, with the server permissions each of them holds there.`,
+		parameters: Type.Object({}, strict),
+	},
+	discord_list_channels: {
+		label: "List channels",
+		describe: (o) =>
+			`List a server's channels and categories that both ${o.name} and ${assistantName()} can see.`,
+		parameters: Type.Object(guild, strict),
+	},
+	discord_list_roles: {
+		label: "List roles",
+		describe: () =>
+			"List a server's roles, highest first, with their permissions.",
+		parameters: Type.Object(guild, strict),
+	},
+	discord_find_members: {
+		label: "Find members",
+		describe: () =>
+			"Find server members whose username or server nickname starts with the query.",
+		parameters: Type.Object(
+			{
+				...guild,
+				query: Type.String({ minLength: 1, maxLength: 100 }),
+				limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 25 })),
+			},
+			strict,
+		),
+	},
+	discord_create_channel: {
+		label: "Create channel",
+		describe: () =>
+			"Create a text, voice, or announcement channel, or a category.",
+		parameters: Type.Object(
+			{
+				...guild,
+				name: Type.String({ minLength: 1, maxLength: 100 }),
+				type: Type.Union(
+					["text", "voice", "announcement", "category"].map((v) =>
+						Type.Literal(v),
+					),
+				),
+				parentId: Type.Optional(id),
+				topic: Type.Optional(Type.String({ maxLength: 1024 })),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_delete_channel: {
+		label: "Delete channel",
+		describe: () => "Delete a channel, category, or thread.",
+		parameters: Type.Object({ channelId: id, reason }, strict),
+	},
+	discord_list_threads: {
+		label: "List threads",
+		describe: (o) =>
+			`List a server's active threads that both ${o.name} and ${assistantName()} can see, optionally only those under one channel; with archived, list that channel's archived threads instead. The message tools take a thread's id as channelId.`,
+		parameters: Type.Object(
+			{
+				...guild,
+				parentId: Type.Optional(id),
+				archived: Type.Optional(
+					Type.Boolean({ description: "Needs parentId." }),
+				),
+			},
+			strict,
+		),
+	},
+	discord_create_thread: {
+		label: "Start thread",
+		describe: (o) =>
+			`Start a thread in a text or announcement channel, from one of its messages or on its own. A private thread (text channels only, not from a message) gets ${o.name} added. Post in it with discord_send_message using the thread's id.`,
+		parameters: Type.Object(
+			{
+				channelId: id,
+				name: Type.String({ minLength: 1, maxLength: 100 }),
+				messageId: Type.Optional(id),
+				private: Type.Optional(Type.Boolean()),
+				autoArchiveMinutes: Type.Optional(autoArchive),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_edit_thread: {
+		label: "Edit thread",
+		describe: () =>
+			"Rename a thread, archive or unarchive it, lock or unlock it, or change when it auto-archives.",
+		parameters: Type.Object(
+			{
+				threadId: id,
+				name: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+				archived: Type.Optional(Type.Boolean()),
+				locked: Type.Optional(
+					Type.Boolean({
+						description: "Only members who can manage threads may post.",
+					}),
+				),
+				autoArchiveMinutes: Type.Optional(autoArchive),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_create_role: {
+		label: "Create role",
+		describe: () => "Create a role.",
+		parameters: Type.Object(
+			{
+				...guild,
+				...roleFields,
+				name: Type.String({ minLength: 1, maxLength: 100 }),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_edit_role: {
+		label: "Edit role",
+		describe: () =>
+			"Change a role's name, color, display, or permissions; permissions replaces the whole set.",
+		parameters: Type.Object(
+			{ ...guild, roleId: id, ...roleFields, reason },
+			strict,
+		),
+	},
+	discord_delete_role: {
+		label: "Delete role",
+		describe: () => "Delete a role.",
+		parameters: Type.Object({ ...guild, roleId: id, reason }, strict),
+	},
+	discord_add_member_role: {
+		label: "Give role",
+		describe: () => "Give a member a role.",
+		parameters: Type.Object({ ...member, roleId: id, reason }, strict),
+	},
+	discord_remove_member_role: {
+		label: "Take role",
+		describe: () => "Take a role from a member.",
+		parameters: Type.Object({ ...member, roleId: id, reason }, strict),
+	},
+	discord_set_nickname: {
+		label: "Set nickname",
+		describe: () =>
+			`Set a member's server nickname; an empty nickname clears it. ${assistantName()}'s own id changes its name in that server.`,
+		parameters: Type.Object(
+			{ ...member, nickname: Type.String({ maxLength: 32 }), reason },
+			strict,
+		),
+	},
+	discord_timeout_member: {
+		label: "Time out member",
+		describe: () =>
+			"Stop a member from talking for some minutes; 0 lifts a timeout.",
+		parameters: Type.Object(
+			{
+				...member,
+				minutes: Type.Integer({ minimum: 0, maximum: 40320 }),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_kick_member: {
+		label: "Kick member",
+		describe: () => "Remove a member from the server; they can join again.",
+		parameters: Type.Object({ ...member, reason }, strict),
+	},
+	discord_ban_member: {
+		label: "Ban member",
+		describe: () =>
+			"Ban a user from the server, optionally deleting their recent messages.",
+		parameters: Type.Object(
+			{
+				...member,
+				deleteMessageSeconds: Type.Optional(
+					Type.Integer({ minimum: 0, maximum: 604800 }),
+				),
+				reason,
+			},
+			strict,
+		),
+	},
+	discord_unban_member: {
+		label: "Unban member",
+		describe: () => "Lift a user's ban.",
+		parameters: Type.Object({ ...member, reason }, strict),
+	},
+};
+
+/** Every Discord tool of the owner's `discord` profile. */
+export const DISCORD_OWNER_TOOLS = [
+	...Object.keys(CHANNEL_TOOLS),
+	...Object.keys(SERVER_TOOLS),
+];
+
+/** Runs one Discord tool for the owner; throws ChannelToolError for a refused call. */
+export interface OwnerDiscord {
+	run(tool: string, args: Record<string, unknown>): Promise<unknown>;
+}
+
+export function discordAdminExtension(
+	discord: OwnerDiscord,
+	owner: OwnerIdentity,
+): ExtensionFactory {
+	const o = ownerWords(owner);
+	const specs = [
+		...Object.entries(CHANNEL_TOOLS).map(([name, spec]) => ({
+			name,
+			label: name,
+			description: spec.description,
+			parameters: spec.schema,
+		})),
+		...Object.entries(SERVER_TOOLS).map(([name, spec]) => ({
+			name,
+			label: spec.label,
+			description: spec.describe(o),
+			parameters: spec.parameters,
+		})),
+	];
+	return textToolsExtension(
+		specs.map((spec) => ({
+			...spec,
+			run: async (input) => JSON.stringify(await discord.run(spec.name, input)),
+		})),
+		ChannelToolError,
+	);
+}