pi-roundtable 0.26.1 → 0.26.2

package/src/core/runtime/extensions/late-releases.ts

@@ -0,0 +1,76 @@
+import type { HeldCall } from "../../domain/conversation.ts";
+import { SYSTEM_PRINCIPAL } from "../../identity/principal-store.ts";
+import type { Release, SpeakerRef } from "./gate-refusals.ts";
+import { sameCall } from "./held-calls.ts";
+
+/**
+ * How long a late approval's release waits for the call it was granted for. The turn that
+ * answers a late card re-makes the call at once, so an hour covers a slow model or a queue of
+ * turns and no more; a release nobody spent by then belongs to a call that is long gone.
+ */
+export const LATE_RELEASE_TTL_MS = 3_600_000;
+
+/**
+ * The releases that cards answered after their turn stopped waiting earned. A release lets the
+ * identical call run once, only while it is fresh and only in a turn spoken by the person who gave it
+ * (or by an owner), only in a turn a person's message started, and it is dropped when the identical call
+ * runs without a hold, since that run is the call the person approved.
+ */
+export class LateReleases {
+	#list: { release: Release; at: number }[] = [];
+
+	add(release: Release, now = Date.now()): void {
+		this.#prune(now);
+		this.#list.push({ release, at: now });
+	}
+
+	/**
+	 * Takes the release of `call` that `speaker` may spend out of the list; undefined when none
+	 * is fresh and theirs. A release whose approver is unknown is anyone's.
+	 */
+	spend(
+		call: Pick<HeldCall, "tool" | "input">,
+		speaker: SpeakerRef | undefined,
+		now = Date.now(),
+	): Release | undefined {
+		this.#prune(now);
+		const at = this.#list.findIndex(
+			({ release }) =>
+				sameCall(release.call, call) && maySpend(release, speaker),
+		);
+		if (at === -1) return undefined;
+		const [spent] = this.#list.splice(at, 1);
+		return spent?.release;
+	}
+
+	/** Drops every release of `call`, whoever gave it. */
+	drop(call: Pick<HeldCall, "tool" | "input">): void {
+		this.#list = this.#list.filter(
+			({ release }) => !sameCall(release.call, call),
+		);
+	}
+
+	/** Whether a fresh release of `call` waits, for whoever may spend it. */
+	has(call: Pick<HeldCall, "tool" | "input">, now = Date.now()): boolean {
+		this.#prune(now);
+		return this.#list.some(({ release }) => sameCall(release.call, call));
+	}
+
+	#prune(now: number): void {
+		this.#list = this.#list.filter(({ at }) => now - at <= LATE_RELEASE_TTL_MS);
+	}
+}
+
+/**
+ * Whether `speaker` may spend `release`: they gave it, or are an owner; any speaker, when its
+ * giver is unknown. The gate hands only the speaker of a turn a person's
+ * message started; every other turn (schedule, agent message, report, error report) has none and
+ * spends nothing, so a card is shown again there. The system principal never spends one.
+ */
+function maySpend(release: Release, speaker: SpeakerRef | undefined): boolean {
+	if (!speaker || speaker.principalId === SYSTEM_PRINCIPAL) return false;
+	if (!release.by) return true;
+	return (
+		speaker.tier === "owner" || speaker.principalId === release.by.principalId
+	);
+}

package/src/core/runtime/pi-agent-runtime.ts

@@ -21,10 +21,9 @@ import type { TurnRequest } from "../domain/ports.ts";
 import { HostStoppingError } from "../errors.ts";
 import { assistantName } from "../i18n/index.ts";
 import { promptScopeOf } from "../interactions/prompts.ts";
-import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
 import { withoutReplyFiles } from "../reply-files.ts";
 import type { TransientTask } from "../sessions.ts";
-import { type ToolTiers, toolsForTier, toolTiers } from "../tool-tiers.ts";
+import { type ToolTiers, toolTiers } from "../tool-tiers.ts";
 import { AbortGuard } from "./abort-guard.ts";
 import { bridgeTurnRefusal, chosenAgentModel } from "./bridge-guard.ts";
 import { ConversationSessions } from "./conversation-sessions.ts";
@@ -52,6 +51,7 @@ import { transcriptOf, turnAnswer, unspokenTurn } from "./turn-answer.ts";
 import type { TurnBudget } from "./turn-budget.ts";
 import { promptFailed, turnLimits } from "./turn-limits.ts";
 import { progressReporter } from "./turn-progress.ts";
+import { turnTools } from "./turn-tools.ts";
 import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
 
@@ -62,8 +62,6 @@ export {
 	sessionExtensions,
 } from "./runtime-types.ts";
 
-const MEMORY = new Set<string>(MEMORY_TOOLS);
-
 /** AgentRuntime over the Pi SDK: one persistent session per channel, each with its own loader. */
 const STOPPED = "stopped by the owner";
 
@@ -183,18 +181,15 @@ export class PiAgentRuntime implements AgentRuntime {
 			request.agent !== undefined &&
 			this.#options.agents?.memory === "owners" &&
 			tier !== "owner";
-		const wanted = toolsForTier(
-			[
-				...new Set([
-					...this.#factory.toolsFor(request.selection),
-					...(request.confirmed && pending
-						? pending.calls.map((call) => call.tool)
-						: []),
-				]),
-			],
-			tier,
+		const wanted = turnTools(
+			{
+				selected: this.#factory.toolsFor(request.selection),
+				held: request.confirmed && pending ? pending.calls : [],
+				tier,
+				withheld,
+			},
 			this.#tiers,
-		).filter((name) => !withheld || !MEMORY.has(name));
+		);
 		const markPrivateMemory = recordMemoryTurn(
 			session.sessionManager,
 			request.speaker.principalId,
@@ -221,6 +216,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			request.speaker,
 			conversation.visibility === "private",
 			turnYolo(this.#options, request),
+			request.byMessage === true,
 		);
 		if (request.confirmed && pending && pending.calls.length > 0) {
 			logger.info(
@@ -231,7 +227,6 @@ export class PiAgentRuntime implements AgentRuntime {
 				"confirmed actions released",
 			);
 		}
-
 		// Collected as they end: a compaction during the turn shortens session.messages.
 		const turnMessages: TurnMessage[] = [];
 		const toolCalls: string[] = [];
@@ -240,8 +235,12 @@ export class PiAgentRuntime implements AgentRuntime {
 		// The caller's live view: the text as it streams and each tool, never the thinking.
 		const slot = this.#sessions.slot(key);
 		// Its time limit, not counting time waiting on the owner's cards, follows what it does to say why it fired.
-		const limits = turnLimits(this.#options, slot, request.channel, () =>
-			guard.abort(),
+		const limits = turnLimits(
+			this.#options,
+			slot,
+			request.channel,
+			() => guard.abort(),
+			request.timeLimitMs,
 		);
 		const progress = request.progress
 			? progressReporter(request.progress, {
@@ -333,7 +332,10 @@ export class PiAgentRuntime implements AgentRuntime {
 
 		if (running.stopped)
 			return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-		return limits.failure() ?? turnAnswer(turnMessages, running.steered);
+		return (
+			limits.failure() ??
+			turnAnswer(turnMessages, running.steered, request.unattended !== true)
+		);
 	}
 
 	async steer(

package/src/core/runtime/turn-answer.ts

@@ -77,11 +77,14 @@ export function thinkingOf(messages: readonly Message[]): string {
 
 /**
  * A finished turn's result from the messages it added. A steered run may have answered before
- * the steer arrived, so every final answer of it is kept.
+ * the steer arrived, so every final answer of it is kept. A turn nobody waits on (`attended`
+ * false: a schedule's, an agent's message) may end with nothing to say, such as "send nothing if
+ * there is no progress"; that is an empty answer, not a failure. For an attended turn it is one.
  */
 export function turnAnswer(
 	messages: readonly Message[],
 	steered: boolean,
+	attended: boolean,
 ): TurnResult {
 	const last = lastAssistant(messages);
 	if (!last.ok) return { ok: false, error: new AgentRunError(last.error) };
@@ -97,6 +100,7 @@ export function turnAnswer(
 					.join("\n\n")
 			: textOf(last.message.content)
 	).trim();
+	if (!text && !hasReplyFiles() && !attended) return { ok: true, text: "" };
 	if (!text && !hasReplyFiles())
 		return {
 			ok: false,

package/src/core/runtime/turn-budget.ts

@@ -167,6 +167,7 @@ export function runtimeTurnBudget(
 		...seams.activity.now(clock.now()),
 		graceMs,
 		end,
+		...(slot.cards ? {} : { unasked: true as const }),
 	});
 	const stop = (timeout: TurnTimeout) => {
 		logger.warn(

package/src/core/runtime/turn-limits.ts

@@ -35,7 +35,8 @@ export function timeoutMessage(timeout: TurnTimeout): string {
 /**
  * The time limit of a turn of the built-in runtime; see `runtimeTurnBudget`. `abort` aborts the
  * turn. In a long-running conversation (`options.modes`) a limit extends the turn instead of
- * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`.
+ * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`. A
+ * `timeLimitMs` replaces the turn's limit and its cap, both held under that same ceiling.
  */
 export function turnLimits(
 	options: Parameters<typeof runtimeTurnBudget>[0] &
@@ -43,15 +44,24 @@ export function turnLimits(
 	slot: Pick<PromptSlot, "waitedMs" | "cards">,
 	channel: ChannelKey,
 	abort: () => void,
+	timeLimitMs?: number,
 ): TurnLimits {
 	const { longRunningMaxMs } = options.autonomy ?? DEFAULT_AUTONOMY;
+	const limited =
+		timeLimitMs === undefined
+			? options
+			: {
+					...options,
+					turnTimeoutMs: Math.min(timeLimitMs, longRunningMaxMs),
+					turnMaxMs: Math.min(timeLimitMs, longRunningMaxMs),
+				};
 	const keepGoing = (workedMs: number) =>
 		workedMs < longRunningMaxMs &&
 		options.modes?.peek(channel).longRunning === true;
 	const activity = activityTracker();
 	let timedOut: TurnTimeout | undefined;
 	const budget = runtimeTurnBudget(
-		options,
+		limited,
 		slot,
 		channel,
 		(timeout) => {

package/src/core/runtime/turn-tools.ts

@@ -0,0 +1,26 @@
+import type { HeldCall } from "../domain/conversation.ts";
+import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
+import type { Tier } from "../speakers.ts";
+import { type ToolTiers, toolsForTier } from "../tool-tiers.ts";
+
+const MEMORY = new Set<string>(MEMORY_TOOLS);
+
+/**
+ * The tools a turn is given: its selection, and the tools of the held calls an approving turn
+ * releases, limited to the speaker's tier; a speaker kept out of memory gets none of its tools.
+ */
+export function turnTools(
+	turn: {
+		selected: readonly string[];
+		held: readonly Pick<HeldCall, "tool">[];
+		tier: Tier;
+		withheld: boolean;
+	},
+	tiers: ToolTiers,
+): string[] {
+	return toolsForTier(
+		[...new Set([...turn.selected, ...turn.held.map((call) => call.tool)])],
+		turn.tier,
+		tiers,
+	).filter((name) => !turn.withheld || !MEMORY.has(name));
+}

package/src/core/shared/schedule-tools.ts

@@ -13,6 +13,9 @@ export const SCHEDULE_TOOLS = Object.freeze([
 ] as const);
 export type ScheduleToolName = (typeof SCHEDULE_TOOLS)[number];
 
+/** The most minutes a schedule's own time limit may name: the four hours a long-running turn may work. */
+export const MAX_SCHEDULE_TIME_LIMIT_MINUTES = 240;
+
 export function isScheduleTool(value: string): value is ScheduleToolName {
 	return (SCHEDULE_TOOLS as readonly string[]).includes(value);
 }
@@ -62,6 +65,8 @@ const timing = (zone: string) => ({
 	),
 });
 
+const TIME_LIMIT = `How long, in minutes, each run may work before it is stopped (at most ${MAX_SCHEDULE_TIME_LIMIT_MINUTES}); without it a run is stopped after the host's default of 10 minutes. Set it for a task that works longer.`;
+
 export interface ScheduleToolSpec {
 	name: ScheduleToolName;
 	label: string;
@@ -118,6 +123,13 @@ export function scheduleToolSpecs(
 							"The name of a precheck the host runs first, from schedule_list; you are woken only when it finds something.",
 					}),
 				),
+				time_limit_minutes: Type.Optional(
+					Type.Integer({
+						minimum: 1,
+						maximum: MAX_SCHEDULE_TIME_LIMIT_MINUTES,
+						description: TIME_LIMIT,
+					}),
+				),
 				...script(false),
 			}),
 		},
@@ -133,7 +145,7 @@ export function scheduleToolSpecs(
 			name: "schedule_update",
 			label: "Update schedule",
 			description:
-				"Change one of this channel's schedules: its title, its prompt, its timing (timing fields replace the old timing), or its precheck. A run can use this to keep its own prompt current, such as adding what it already reported.",
+				"Change one of this channel's schedules: its title, its prompt, its timing (timing fields replace the old timing), its precheck, or its time limit. A run can use this to keep its own prompt current, such as adding what it already reported.",
 			parameters: Type.Object({
 				id: Type.Integer({ description: "Schedule id." }),
 				title: Type.Optional(Type.String()),
@@ -147,6 +159,18 @@ export function scheduleToolSpecs(
 							"A precheck's name from schedule_list to run first, or null to remove the schedule's precheck.",
 					}),
 				),
+				time_limit_minutes: Type.Optional(
+					Type.Union(
+						[
+							Type.Integer({
+								minimum: 1,
+								maximum: MAX_SCHEDULE_TIME_LIMIT_MINUTES,
+							}),
+							Type.Null(),
+						],
+						{ description: `${TIME_LIMIT} null returns it to the default.` },
+					),
+				),
 				...script(true),
 			}),
 		},