@zetaloop/chappie 0.5.0 → 1.0.0

package/src/questions.ts

@@ -1,87 +0,0 @@
-import * as z from "zod";
-
-export const questionInstructions =
-	"ask requests a question widget in ChatGPT; its result confirms creation of the request. Immediately call ask_assert with question.id to confirm loading. If the widget fails to load within 10 seconds, the assertion fails and records the question as skipped. Use an installed Pi interactive tool through call when an answer is needed. User answers arrive separately as webAnswer in normal tool results. Apply answers and revisions promptly; a user skip means proceed with available information.";
-
-export const questionInput = z.object({
-	header: z.string().trim().min(1).optional().describe("Short topic label"),
-	question: z
-		.string()
-		.trim()
-		.min(1)
-		.describe("One focused question for the user"),
-	context: z
-		.string()
-		.optional()
-		.describe("Background needed to answer the question"),
-	options: z
-		.array(
-			z.object({
-				title: z.string().trim().min(1).describe("Short choice label"),
-				description: z
-					.string()
-					.optional()
-					.describe("Brief consequence or tradeoff of this choice"),
-				recommended: z
-					.boolean()
-					.optional()
-					.describe("Preferred choice; place it first"),
-			}),
-		)
-		.default([])
-		.describe(
-			"Distinct choices, usually two or three. Freeform answers and skipping are available separately.",
-		),
-	allowMultiple: z
-		.boolean()
-		.default(false)
-		.describe("Allow selecting several options"),
-});
-
-export const answerInput = z.object({
-	selections: z.array(z.number().int().nonnegative()).default([]),
-	text: z.string().trim().default(""),
-	skipped: z.literal(true).optional().describe("The question was skipped"),
-});
-
-export const questionOutput = questionInput.extend({
-	id: z.string().describe("Generated question ID for ask_assert"),
-	sessionId: z.string(),
-	cwd: z.string(),
-	answer: answerInput.optional(),
-	loaded: z.boolean().optional().describe("The widget has reported loading"),
-});
-
-export type QuestionInput = z.infer<typeof questionInput>;
-export type QuestionAnswer = z.infer<typeof answerInput>;
-export type Question = z.infer<typeof questionOutput>;
-
-export interface QuestionRecord extends Question {
-	chatId: string;
-	delivered: boolean;
-}
-
-export function questionView(record: QuestionRecord): Question {
-	const { chatId: _chatId, delivered: _delivered, ...question } = record;
-	return question;
-}
-
-export function answerContent(records: QuestionRecord[]) {
-	return records.map((record) => ({
-		type: "text" as const,
-		text: JSON.stringify({
-			webAnswer: {
-				questionId: record.id,
-				sessionId: record.sessionId,
-				cwd: record.cwd,
-				header: record.header,
-				question: record.question,
-				skipped: record.answer?.skipped,
-				choices: record.answer?.selections.map(
-					(index) => record.options[index],
-				),
-				text: record.answer?.text,
-			},
-		}),
-	}));
-}

package/src/resources.ts

@@ -1,209 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { open, readFile, stat } from "node:fs/promises";
-import { basename } from "node:path";
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-import mime from "mime";
-
-export interface ResourceDescriptor {
-	uri: string;
-	name: string;
-	mimeType: string;
-	size: number;
-}
-
-export interface ResourceData extends ResourceDescriptor {
-	blob: string;
-}
-
-type ResourceEntry =
-	| { type: "file"; path: string; descriptor: ResourceDescriptor }
-	| { type: "image"; data: string; descriptor: ResourceDescriptor };
-
-const stores = new Map<string, Map<string, ResourceEntry>>();
-
-export async function registerFile(
-	sessionId: string,
-	path: string,
-): Promise<ResourceDescriptor> {
-	const info = await stat(path);
-	if (!info.isFile()) throw new Error(`${path} is not a file`);
-	const name = basename(path);
-	const descriptor = resourceDescriptor(
-		sessionId,
-		"file",
-		randomUUID(),
-		name,
-		mime.getType(path) ?? "application/octet-stream",
-		info.size,
-	);
-	store(sessionId).set(descriptor.uri, { type: "file", path, descriptor });
-	return descriptor;
-}
-
-export function rememberImages(
-	sessionId: string,
-	content: readonly (TextContent | ImageContent)[],
-): void {
-	for (const block of content) {
-		if (block.type !== "image") continue;
-		const descriptor = imageDescriptor(sessionId, block);
-		store(sessionId).set(descriptor.uri, {
-			type: "image",
-			data: block.data,
-			descriptor,
-		});
-	}
-}
-
-export function imageDescriptor(
-	sessionId: string,
-	image: ImageContent,
-): ResourceDescriptor {
-	const digest = createHash("sha256")
-		.update(image.data, "base64")
-		.digest("hex");
-	const extension = mime.getExtension(image.mimeType) ?? "bin";
-	return resourceDescriptor(
-		sessionId,
-		"image",
-		digest,
-		`image.${extension}`,
-		image.mimeType,
-		Buffer.byteLength(image.data, "base64"),
-	);
-}
-
-export function contentWithImageReferences(
-	sessionId: string,
-	content: readonly (TextContent | ImageContent)[],
-): (TextContent | ImageContent)[] {
-	return content.flatMap((block) =>
-		block.type === "image"
-			? [
-					block,
-					{
-						type: "text" as const,
-						text: JSON.stringify({
-							piImage: imageDescriptor(sessionId, block).uri,
-						}),
-					},
-				]
-			: [block],
-	);
-}
-
-export function resourceDescriptors(details: unknown): ResourceDescriptor[] {
-	if (!details || typeof details !== "object") return [];
-	const resources = (details as { resources?: unknown }).resources;
-	if (!Array.isArray(resources)) return [];
-	return resources.filter((resource): resource is ResourceDescriptor => {
-		if (!resource || typeof resource !== "object") return false;
-		const value = resource as Partial<ResourceDescriptor>;
-		return (
-			typeof value.uri === "string" &&
-			typeof value.name === "string" &&
-			typeof value.mimeType === "string" &&
-			typeof value.size === "number"
-		);
-	});
-}
-
-export function describeResource(
-	sessionId: string,
-	uri: string,
-): ResourceDescriptor {
-	const parsed = parseResourceUri(uri);
-	if (parsed.sessionId !== sessionId) {
-		throw new Error("The resource belongs to another Pi session");
-	}
-	const entry = store(sessionId).get(uri);
-	if (!entry) throw new Error(`Unknown Chappie resource: ${uri}`);
-	return entry.descriptor;
-}
-
-export async function readSessionResource(
-	sessionId: string,
-	uri: string,
-	offset?: number,
-): Promise<ResourceData> {
-	const descriptor = describeResource(sessionId, uri);
-	const entry = store(sessionId).get(uri);
-	if (!entry) throw new Error(`Unknown Chappie resource: ${uri}`);
-	if (offset === undefined) {
-		const blob =
-			entry.type === "file"
-				? (await readFile(entry.path)).toString("base64")
-				: entry.data;
-		return { ...descriptor, blob };
-	}
-	if (!Number.isSafeInteger(offset) || offset < 0)
-		throw new Error("Resource offset must be a nonnegative integer");
-	const length = Math.min(1024 * 1024, Math.max(0, descriptor.size - offset));
-	let data: Buffer;
-	if (entry.type === "file") {
-		await using file = await open(entry.path, "r");
-		const { buffer, bytesRead } = await file.read(
-			Buffer.alloc(length),
-			0,
-			length,
-			offset,
-		);
-		data = buffer.subarray(0, bytesRead);
-	} else {
-		data = Buffer.from(entry.data, "base64").subarray(offset, offset + length);
-	}
-	return { ...descriptor, blob: data.toString("base64") };
-}
-
-export function resourceSessionId(uri: string): string {
-	return parseResourceUri(uri).sessionId;
-}
-
-function store(sessionId: string): Map<string, ResourceEntry> {
-	let resources = stores.get(sessionId);
-	if (!resources) {
-		resources = new Map();
-		stores.set(sessionId, resources);
-	}
-	return resources;
-}
-
-function resourceDescriptor(
-	sessionId: string,
-	kind: "file" | "image",
-	id: string,
-	name: string,
-	mimeType: string,
-	size: number,
-): ResourceDescriptor {
-	return {
-		uri: `chappie://session/${encodeURIComponent(sessionId)}/${kind}/${encodeURIComponent(id)}/${encodeURIComponent(name)}`,
-		name,
-		mimeType,
-		size,
-	};
-}
-
-function parseResourceUri(uri: string): {
-	sessionId: string;
-	kind: string;
-	id: string;
-	name: string;
-} {
-	const parsed = new URL(uri);
-	if (parsed.protocol !== "chappie:" || parsed.hostname !== "session") {
-		throw new Error(`Unsupported Chappie resource: ${uri}`);
-	}
-	const parts = parsed.pathname
-		.slice(1)
-		.split("/")
-		.map((part) => decodeURIComponent(part));
-	if (parts.length !== 4 || !parts.every(Boolean)) {
-		throw new Error(`Invalid Chappie resource: ${uri}`);
-	}
-	const [sessionId, kind, id, name] = parts;
-	if (!sessionId || !kind || !id || !name) {
-		throw new Error(`Invalid Chappie resource: ${uri}`);
-	}
-	return { sessionId, kind, id, name };
-}