@astrosheep/pi-context 0.9.0 → 0.10.0

package/src/note-tools.ts

@@ -0,0 +1,76 @@
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { output } from "./tool-output.js";
+import { nullableString, nullableInteger, positiveInteger } from "./tool-schema.js";
+import { notesFromSession, assertVirtualPath, assertVirtualPrefix, lineRange, localIso, type NoteOperation } from "./notes.js";
+import { NOTE_TYPE, MAX_NOTE_BYTES } from "./protocol.js";
+
+export function registerNoteTools(pi: ExtensionAPI) {
+	const saveNote = (op: NoteOperation) => {
+		// pi.appendEntry writes a custom SessionManager entry. Custom entries are persistent but excluded from LLM context.
+		// ExtensionContext deliberately exposes only a readonly SessionManager, so this is the public extension write path.
+		pi.appendEntry(NOTE_TYPE, op);
+	};
+
+	pi.registerTool(defineTool({
+		name: "notes_list_files_by_prefix",
+		label: "Notes list files",
+		description: "List persistent, session-scoped virtual note files. created_at and updated_at are local-time ISO 8601 strings with an explicit UTC offset.",
+		parameters: Type.Object({ prefix: nullableString(), max_results: positiveInteger(), file_order_by: Type.Optional(Type.Union([Type.Literal("name"), Type.Literal("created_at"), Type.Literal("updated_at")])), file_order: Type.Optional(Type.Union([Type.Literal("ascending"), Type.Literal("descending")])) }, { additionalProperties: false }),
+		async execute(_id, params, _signal, _update, ctx) {
+			const prefix = assertVirtualPrefix(params.prefix);
+			let files = [...notesFromSession(ctx)].filter(([path]) => !prefix || path.startsWith(prefix));
+			const key = params.file_order_by ?? "name";
+			files.sort(([aPath, a], [bPath, b]) => key === "name" ? aPath.localeCompare(bPath) : (key === "created_at" ? a.createdAt - b.createdAt : a.updatedAt - b.updatedAt));
+			if (params.file_order === "descending") files.reverse();
+			return output({ files: files.slice(0, params.max_results ?? files.length).map(([path, file]) => ({ path, size_bytes: Buffer.byteLength(file.text, "utf8"), created_at: localIso(file.createdAt), updated_at: localIso(file.updatedAt) })) });
+		},
+	}));
+
+	pi.registerTool(defineTool({
+		name: "notes_read_file",
+		label: "Notes read file",
+		description: "Read a virtual note file, optionally by inclusive 1-based line range; negative lines count from the end. Success results carry created_at and updated_at as local-time ISO 8601 strings with an explicit UTC offset.",
+		parameters: Type.Object({ path: Type.String(), start_line: nullableInteger(), stop_line: nullableInteger() }, { additionalProperties: false }),
+		async execute(_id, params, _signal, _update, ctx) {
+			const path = assertVirtualPath(params.path);
+			const file = notesFromSession(ctx).get(path);
+			if (!file) return output({ error: "note file not found", path });
+			return output({ path, ...lineRange(file.text, params.start_line, params.stop_line), created_at: localIso(file.createdAt), updated_at: localIso(file.updatedAt) });
+		},
+	}));
+
+	pi.registerTool(defineTool({
+		name: "notes_search_contents",
+		label: "Notes search",
+		description: "Case-sensitive literal substring search over virtual note lines; no semantic search. Each matched file carries created_at and updated_at as local-time ISO 8601 strings with an explicit UTC offset.",
+		parameters: Type.Object({ max_matches_per_file: positiveInteger(), query: Type.String(), recent_file_first: Type.Optional(Type.Boolean()), max_files: positiveInteger(), path_prefix: nullableString() }, { additionalProperties: false }),
+		async execute(_id, params, _signal, _update, ctx) {
+			const prefix = assertVirtualPrefix(params.path_prefix);
+			let files = [...notesFromSession(ctx)].filter(([path]) => !prefix || path.startsWith(prefix));
+			if (params.recent_file_first) files.sort((a, b) => b[1].createdAt - a[1].createdAt);
+			const maxPerFile = params.max_matches_per_file ?? Number.POSITIVE_INFINITY;
+			const result = files.map(([path, file]) => ({ path, created_at: localIso(file.createdAt), updated_at: localIso(file.updatedAt), matches: file.text.split("\n").flatMap((line, index) => line.includes(params.query) ? [{ line: index + 1, text: line }] : []).slice(0, maxPerFile) })).filter((file) => file.matches.length > 0);
+			return output({ files: result.slice(0, params.max_files ?? result.length) });
+		},
+	}));
+
+	for (const [name, op] of [["notes_append_to_file", "append"], ["notes_write_file", "write"]] as const) {
+		pi.registerTool(defineTool({
+			name,
+			label: name === "notes_append_to_file" ? "Notes append" : "Notes write",
+			description: name === "notes_append_to_file" ? "Append exact text to a persistent virtual note file." : "Create or replace a persistent virtual note file.",
+			parameters: Type.Object({ text: Type.String(), path: Type.String() }, { additionalProperties: false }),
+			async execute(_id, params, _signal, _update, ctx) {
+				const path = assertVirtualPath(params.path);
+				const old = notesFromSession(ctx).get(path);
+				const next = op === "append" ? `${old?.text ?? ""}${params.text}` : params.text;
+				const bytes = Buffer.byteLength(next, "utf8");
+				if (bytes > MAX_NOTE_BYTES) return output({ error: `note exceeds ${MAX_NOTE_BYTES} UTF-8 bytes`, path, size_bytes: bytes });
+				const now = Date.now();
+				saveNote({ op, path, text: params.text, createdAt: old?.createdAt ?? now, updatedAt: now });
+				return output({ path, size_bytes: bytes, operation: op });
+			},
+		}));
+	}
+}

package/src/notes.ts

@@ -0,0 +1,85 @@
+import type { SessionReader } from "./session-reader.js";
+import { MAX_NOTE_BYTES, NOTE_TYPE } from "./protocol.js";
+
+export type NoteFile = { text: string; createdAt: number; updatedAt: number };
+export type NoteOperation = {
+	op: "write" | "append";
+	path: string;
+	text: string;
+	createdAt: number;
+	updatedAt: number;
+};
+export function assertVirtualPath(value: unknown): string {
+	if (typeof value !== "string" || value.length === 0) throw new Error("path must be a non-empty virtual relative path");
+	if (value.includes("\0") || value.includes("\\") || value.startsWith("/")) throw new Error("path must be a safe virtual relative path");
+	const parts = value.split("/");
+	if (parts.some((part) => part.length === 0 || part === "." || part === "..")) throw new Error("path contains an unsupported component");
+	return value;
+}
+
+export function assertVirtualPrefix(value: unknown): string | undefined {
+	if (value === undefined || value === null || value === "") return undefined;
+	return assertVirtualPath(value);
+}
+
+/** Replays only pi-context note operations from session custom entries. */
+function isNoteOperation(data: unknown): data is NoteOperation {
+	if (typeof data !== "object" || data === null) return false;
+	const op = data as Partial<NoteOperation>;
+	return (
+		(op.op === "write" || op.op === "append") &&
+		typeof op.path === "string" &&
+		typeof op.text === "string" &&
+		typeof op.createdAt === "number" && Number.isFinite(new Date(op.createdAt).getTime()) &&
+		typeof op.updatedAt === "number" && Number.isFinite(new Date(op.updatedAt).getTime())
+	);
+}
+
+export function notesFromSession(ctx: SessionReader): Map<string, NoteFile> {
+	const files = new Map<string, NoteFile>();
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type !== "custom" || entry.customType !== NOTE_TYPE || !isNoteOperation(entry.data)) continue;
+		const op = entry.data;
+		try {
+			assertVirtualPath(op.path);
+		} catch {
+			continue;
+		}
+		const previous = files.get(op.path);
+		const text = op.op === "append" ? `${previous?.text ?? ""}${op.text}` : op.text;
+		if (Buffer.byteLength(text, "utf8") <= MAX_NOTE_BYTES) {
+			files.set(op.path, { text, createdAt: previous?.createdAt ?? op.createdAt, updatedAt: op.updatedAt });
+		}
+	}
+	return files;
+}
+
+export function lineRange(text: string, startValue: unknown, stopValue: unknown) {
+	const lines = text.split("\n");
+	const resolve = (value: unknown, fallback: number) => {
+		if (value === undefined || value === null) return fallback;
+		if (!Number.isInteger(value) || value === 0) throw new Error("line numbers must be non-zero integers; negative values count from the end");
+		const line = value as number;
+		return line > 0 ? line : lines.length + line + 1;
+	};
+	const start = Math.max(1, resolve(startValue, 1));
+	const stop = Math.min(lines.length, resolve(stopValue, lines.length));
+	return { start_line: start, stop_line: stop, content: start > stop ? "" : lines.slice(start - 1, stop).join("\n") };
+}
+
+const pad2 = (value: number) => String(value).padStart(2, "0");
+
+/**
+ * Format epoch milliseconds as an ISO 8601 string in the host's local time zone with an
+ * explicit numeric offset (e.g. 2026-09-15T17:31:45.392+08:00). A UTC host renders
+ * "+00:00"; the "Z" designator is never used, and Date.parse round-trips the value.
+ */
+export function localIso(epochMs: number): string {
+	const date = new Date(epochMs);
+	const offsetMinutes = -date.getTimezoneOffset();
+	const absOffset = Math.abs(offsetMinutes);
+	const offset = `${offsetMinutes < 0 ? "-" : "+"}${pad2(Math.floor(absOffset / 60))}:${pad2(absOffset % 60)}`;
+	const wallClock = `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}T${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}.${String(date.getMilliseconds()).padStart(3, "0")}`;
+	return `${wallClock}${offset}`;
+}
+

package/src/prompts.ts

@@ -0,0 +1,69 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { historyFromSession } from "./history.js";
+import { notesFromSession, localIso } from "./notes.js";
+import { CONTEXT_WINDOW_OPEN_TAG, CONTEXT_WINDOW_CLOSE_TAG, NOTE_PREVIEW_CHARS, NOTE_PREVIEW_HEAD_CHARS, NOTE_PREVIEW_TAIL_CHARS, RESET_SUMMARY, PROTOCOL_BLOCK, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG } from "./protocol.js";
+
+/** Codex-style <context_window> identity block: agent name and first/current/previous window ids only. */
+function identityBlock(agentName: string, firstWindowId: string, currentWindowId: string, previousWindowId?: string): string {
+	const lines = [
+		`Agent name: ${agentName}`,
+		`First context window id: ${firstWindowId}`,
+		`Current context window id: ${currentWindowId}`,
+	];
+	if (previousWindowId) lines.push(`Previous context window id: ${previousWindowId}`);
+	return `${CONTEXT_WINDOW_OPEN_TAG}\n${lines.join("\n")}\n${CONTEXT_WINDOW_CLOSE_TAG}`;
+}
+
+/**
+ * Recent-notes index: up to three most-recent notes. Each note shows its path, line count,
+ * UTF-8 byte count and local ISO update time, followed by an indented inline preview: the
+ * whole text when it fits in NOTE_PREVIEW_CHARS, otherwise its first NOTE_PREVIEW_HEAD_CHARS
+ * and last NOTE_PREVIEW_TAIL_CHARS Unicode characters joined by an explicit ellipsis. The
+ * two slices never overlap, so the preview never duplicates head content as tail content.
+ * Empty when the session has no notes.
+ */
+function notesIndex(ctx: ExtensionContext): string {
+	const recentNotes = [...notesFromSession(ctx)]
+		.sort((a, b) => b[1].updatedAt - a[1].updatedAt)
+		.slice(0, 3);
+	if (recentNotes.length === 0) return "";
+	const lines = ["Recent notes at window open (up to 3, most-recent first):"];
+	for (const [path, file] of recentNotes) {
+		lines.push(`- ${path} (${file.text.split("\n").length} lines, ${Buffer.byteLength(file.text, "utf8")} UTF-8 bytes, updated ${localIso(file.updatedAt)})`);
+		const chars = Array.from(file.text);
+		// Short notes stay whole; long notes keep both ends. head + tail <= NOTE_PREVIEW_CHARS < chars.length,
+		// so the slices are disjoint and no character is shown twice.
+		const preview = chars.length <= NOTE_PREVIEW_CHARS
+			? file.text
+			: `${chars.slice(0, NOTE_PREVIEW_HEAD_CHARS).join("")}…${chars.slice(chars.length - NOTE_PREVIEW_TAIL_CHARS).join("")}`;
+		lines.push(preview.split("\n").map((line) => `  ${line}`).join("\n"));
+	}
+	return lines.join("\n");
+}
+
+/**
+ * Assemble the static, once-per-window boot block: the reset line for resets, the
+ * <context_window> identity block, the recent-notes index at window-open time, and
+ * the <context_window_protocol> teaching block. Nothing here is re-injected, so the
+ * head of the window stays cache-stable.
+ */
+export function bootBlock(ctx: ExtensionContext, currentId: string, previousId: string | undefined, resetLine: boolean): string {
+	const firstId = historyFromSession(ctx)[0]?.windowId ?? currentId;
+	const parts: string[] = [];
+	if (resetLine) parts.push(RESET_SUMMARY);
+	parts.push(identityBlock(ctx.sessionManager.getSessionName() ?? "root", firstId, currentId, previousId));
+	const index = notesIndex(ctx);
+	if (index) parts.push(index);
+	parts.push(PROTOCOL_BLOCK);
+	return parts.join("\n\n");
+}
+
+/**
+ * Codex-equivalent low-budget reminder. The measured remaining count is frozen into
+ * the text at the crossing that fires it, so each persisted copy is a snapshot true
+ * at write time; get_context_remaining remains the live source for the current figure.
+ */
+export function tokenBudgetGuidance(remaining: number): string {
+	return `${GUIDANCE_OPEN_TAG}\nContext budget is running low: only ${remaining} tokens remained when this reminder was recorded. Persist task state, decisions, open issues, and next steps with notes_write_file, including the window ID and item ID of relevant user requests for history_* lookups; call new_context when ready to continue in a fresh window. Automatic reset does not guarantee another note-taking turn. get_context_remaining reports the current remaining tokens.\n${GUIDANCE_CLOSE_TAG}`;
+}
+

package/src/protocol.ts

@@ -0,0 +1,43 @@
+export const STATE_TYPE = "pi-context/state";
+export const NOTE_TYPE = "pi-context/note";
+export const BOOT_TYPE = "pi-context/boot";
+export const GUIDANCE_TYPE = "pi-context/guidance";
+export const FALLBACK_TYPE = "pi-context/fallback";
+export const RESET_MARKER_TYPE = "pi-context/reset-marker";
+export const CONTINUATION_TYPE = "pi-context/continuation";
+export const RESET_V2 = "reset-v2";
+export const MAX_NOTE_BYTES = 1_000_000;
+export const CONTEXT_WINDOW_OPEN_TAG = "<context_window>";
+export const CONTEXT_WINDOW_CLOSE_TAG = "</context_window>";
+export const CONTEXT_WINDOW_PROTOCOL_OPEN_TAG = "<context_window_protocol>";
+export const CONTEXT_WINDOW_PROTOCOL_CLOSE_TAG = "</context_window_protocol>";
+export const GUIDANCE_OPEN_TAG = "<context_window_guidance>";
+export const GUIDANCE_CLOSE_TAG = "</context_window_guidance>";
+export const PI_CONTEXT_SETTINGS_KEY = "pi-context";
+export const DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_REMINDER_MARGIN_TOKENS = 24_576;
+export const RESET_SUMMARY =
+	"Context window reset: this is a fresh window. The previous conversation is not included and no summary was generated. Notes and durable session history persist across windows.";
+export const NOTE_PREVIEW_HEAD_CHARS = 120;
+export const NOTE_PREVIEW_TAIL_CHARS = 80;
+export const NOTE_PREVIEW_CHARS = NOTE_PREVIEW_HEAD_CHARS + NOTE_PREVIEW_TAIL_CHARS;
+export const CONTINUATION = "This is a fresh context window. Recover only the details needed to continue with history_* and notes_*; then continue the task.";
+
+/**
+ * Static protocol teaching adapted from Codex's token_budget.guidance_message to
+ * pi-context's tool names. It lives once per window in the persisted boot block;
+ * it is never re-injected, so it stays cache-stable at the head of the window.
+ */
+export const PROTOCOL_BLOCK = `${CONTEXT_WINDOW_PROTOCOL_OPEN_TAG}
+For tasks that may span context windows, use notes_write_file and notes_append_to_file to maintain a concise checkpoint of the goal, decisions, progress, learnings, and next steps. Include the window ID and item ID of every relevant user request you are currently solving, plus important actions and tool calls. The read-only history_* tools can look up details from those references later. Every non-assistant item (user, tool result) has an item ID returned by history_list_items.
+
+Take incremental notes while you work so you do not lose important information. Use get_context_remaining to check the live remaining token budget for planning. Once the token budget is exhausted you lose access to the current window and continue in a fresh context window; you can recover only through notes_* and history_*. Do not over-run the context window without documentation.
+
+If a Previous context window id is present in <context_window>, a context reset occurred and this is a fresh window. The old conversation is not automatically included. After a reset, read your note checkpoint and use the read-only history_* tools to recover missing details. When a window ID and item ID are known, prefer history_read_item directly; when they are missing or uncertain, use history_list_items, or history_search_contents to locate the item first.
+
+Notes are session-scoped virtual files. Treat notes and history as internal bookkeeping; never mention them in user-facing messages.
+${CONTEXT_WINDOW_PROTOCOL_CLOSE_TAG}`;
+
+export const FALLBACK_PROMPT =
+	"Context budget is almost exhausted. This is the final fallback turn before the window resets automatically. Write task state, decisions, open issues, and next steps with notes_write_file now. Do not start new work; old conversation remains searchable through history_*.";
+

package/src/reset-lifecycle.ts

@@ -0,0 +1,125 @@
+import type { ExtensionAPI, ExtensionContext, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
+
+type ResetResult = { cancel: true } | {
+	compaction: { summary: string; firstKeptEntryId: string; tokensBefore: number; details: unknown };
+};
+
+/** A reset request is session-local. Only this module schedules compaction/continuation. */
+export function registerResetLifecycle(pi: ExtensionAPI, options: {
+	isEnabled: () => boolean;
+	fallback: Parameters<ExtensionAPI["sendMessage"]>[0];
+	continuation: Parameters<ExtensionAPI["sendMessage"]>[0];
+	buildReset: (event: SessionBeforeCompactEvent, ctx: ExtensionContext, explicit: boolean) => ResetResult;
+	isCurrentReset: (entryId: string, ctx: ExtensionContext) => boolean;
+	onReset: (entryId: string) => void;
+}) {
+	type Fallback = "available" | "borrowed" | "ready" | "spent";
+	type Attempt = { completed: boolean; sessionId: string; explicit: boolean };
+	type Request =
+		| { phase: "idle" }
+		| { phase: "requested" }
+		| { phase: "compacting"; attempt: Attempt };
+	let state: Request = { phase: "idle" };
+	let fallback: Fallback = "available";
+	let handledEntry: string | undefined;
+	let active = true;
+
+	const clear = () => {
+		state = { phase: "idle" };
+		fallback = "available";
+		handledEntry = undefined;
+	};
+	const valid = (request: Attempt, ctx: ExtensionContext) =>
+		active && options.isEnabled() && state.phase === "compacting" && state.attempt === request && ctx.sessionManager.getSessionId() === request.sessionId;
+
+	// State is intentionally not resumed from a pending request: a loaded session must
+	// not execute work from a tool that belonged to a previous runtime or tree branch.
+	pi.on("session_start", () => { clear(); active = true; });
+	pi.on("session_shutdown", () => { clear(); active = false; });
+	pi.on("session_tree", clear);
+
+	pi.on("agent_end", (_event, ctx) => {
+		if (!active || !options.isEnabled()) return;
+		if (ctx.signal?.aborted) {
+			// Esc cancels the user's run. Do not reset or resurrect it at settled.
+			state = { phase: "idle" };
+			if (fallback !== "available") fallback = "spent";
+			return;
+		}
+		if (fallback === "borrowed") fallback = "ready";
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		if (!active || !options.isEnabled() || state.phase === "compacting" || !ctx.isIdle()) return;
+		if (state.phase !== "requested" && fallback !== "ready") return;
+		// One owner for explicit and fallback resets. Consume the request before any
+		// external call; repeated settled events and reentrant callbacks are harmless.
+		const request: Attempt = { completed: false, sessionId: ctx.sessionManager.getSessionId(), explicit: state.phase === "requested" };
+		state = { phase: "compacting", attempt: request };
+		if (fallback !== "available") fallback = "spent";
+		const onError = (error: Error) => {
+			if (!valid(request, ctx)) return;
+			state = { phase: "idle" };
+			// Do not retry from settled in a tight loop. A later prompt may trigger a
+			// native reset or explicitly request one; the borrowed allowance stays spent.
+			ctx.ui.notify(`pi-context: reset did not complete (${error.message}). The conversation is retained; resume with another prompt.`, "warning");
+		};
+		try {
+			ctx.compact({
+				onComplete: () => {
+					if (!valid(request, ctx)) return;
+					state = { phase: "idle" };
+					// session_compact only confirms the boundary. onComplete runs after
+					// Pi clears compaction state; sending inside the hook starts too early.
+					// A queued user prompt may already have started at compaction_end.
+					if (request.completed && ctx.isIdle() && !ctx.hasPendingMessages()) {
+						pi.sendMessage(options.continuation, { triggerTurn: true });
+					}
+				},
+				onError,
+			});
+		} catch (error) {
+			onError(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+
+	pi.on("session_before_compact", (event, ctx) => {
+		if (!active || !options.isEnabled()) return undefined;
+		if (event.signal.aborted) return { cancel: true };
+		const automatic = event.reason === "threshold" || event.reason === "overflow";
+		if (automatic && state.phase === "idle" && fallback === "available" && !ctx.isIdle()) {
+			// Pi routes triggerTurn to steer during a run. Idle calls would start a
+			// nested prompt, so pre-prompt automatic compactions always reset directly.
+			fallback = "borrowed";
+			pi.sendMessage(options.fallback, { triggerTurn: true });
+			return { cancel: true };
+		}
+		try {
+			return options.buildReset(event, ctx, state.phase === "requested" || (state.phase === "compacting" && state.attempt.explicit));
+		} catch (error) {
+			ctx.ui.notify(`pi-context: could not build reset (${String(error)}).`, "warning");
+			return { cancel: true }; // Never fall through to a generated default summary.
+		}
+	});
+
+	pi.on("session_compact", (event, ctx) => {
+		if (!active || !options.isEnabled() || handledEntry === event.compactionEntry.id) return;
+		if (!options.isCurrentReset(event.compactionEntry.id, ctx)) return;
+		handledEntry = event.compactionEntry.id;
+		fallback = "available";
+		if (state.phase === "compacting") state.attempt.completed = !event.willRetry;
+		else state = { phase: "idle" };
+		// A native compaction (including overflow retry) owns its own scheduling.
+		// Only a reset we requested gets a continuation from our onComplete callback.
+		options.onReset(event.compactionEntry.id);
+	});
+
+	return {
+		request() {
+			const pending = state.phase !== "idle";
+			if (!pending) state = { phase: "requested" };
+			return pending ? "rollover_already_pending" : "rollover_requested";
+		},
+		clear,
+	};
+}

package/src/session-reader.ts

@@ -0,0 +1,6 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Read-only projection boundary: no UI, scheduling, model, or write capabilities. */
+export type SessionReader = {
+	sessionManager: Pick<ExtensionContext["sessionManager"], "getSessionId" | "getBranch">;
+};

package/src/tool-output.ts

@@ -0,0 +1,8 @@
+function json(value: unknown): string {
+	return JSON.stringify(value, null, 2);
+}
+
+export function output(value: unknown, details: unknown = value, terminate = false) {
+	return { content: [{ type: "text" as const, text: json(value) }], details, terminate };
+}
+

package/src/tool-schema.ts

@@ -0,0 +1,7 @@
+import { Type } from "@earendil-works/pi-ai";
+export const nullableString = () => Type.Optional(Type.Union([Type.String(), Type.Null()]));
+export const nullableInteger = () => Type.Optional(Type.Union([Type.Integer(), Type.Null()]));
+export const positiveInteger = () => Type.Optional(Type.Integer({ minimum: 1 }));
+export const recentFirst = () => Type.Optional(Type.Boolean({ description: "Return newest-first. Only an explicit false returns oldest-first. Defaults to true." }));
+export const role = Type.Union([Type.Literal("user"), Type.Literal("assistant"), Type.Literal("tool"), Type.Literal("system"), Type.Literal("developer"), Type.Null()]);
+