pi-ui-extend 0.1.1

package/dist/app/menu-items-controller.js

@@ -0,0 +1,182 @@
+import { resolve } from "node:path";
+import { fuzzySearch } from "../fuzzy.js";
+import { PI_FAVORITE_MODEL_REFS, THINKING_LEVELS } from "./constants.js";
+import { APP_ICONS } from "./icons.js";
+import { parseScopedModelRef } from "./model-ref.js";
+import { buildUserMessageJumpItems, createSessionInfoMenuItemsLoader } from "./popup-menu-controller.js";
+import { getResourceSlashCommands, getSlashCommandMatches, parseSlashInput } from "./slash-commands.js";
+export class AppMenuItemsController {
+    host;
+    resumeMenuLoaderCache;
+    constructor(host) {
+        this.host = host;
+    }
+    parseSlashInput(text) {
+        return parseSlashInput(text);
+    }
+    getResourceSlashCommands() {
+        return getResourceSlashCommands(this.host.runtime(), this.host.getBuiltinSlashCommands());
+    }
+    getSlashCommandMatches(query, limit) {
+        return getSlashCommandMatches(this.getAllSlashCommands(), query, limit);
+    }
+    getSlashCommandMenuItems(query) {
+        return this.getSlashCommandMatches(query).map((match) => ({
+            value: match.value,
+            label: `/${match.value.name}`,
+            description: match.value.description,
+        }));
+    }
+    modelRef(model) {
+        return `${model.provider}/${model.id}`;
+    }
+    getFavoriteScopedModels() {
+        const configuredRefs = this.host.runtime()?.services.settingsManager.getEnabledModels();
+        const refs = configuredRefs && configuredRefs.length > 0 ? configuredRefs : PI_FAVORITE_MODEL_REFS;
+        return this.resolveScopedModelRefs(refs);
+    }
+    getModelMenuItems(query) {
+        const models = [...this.getModelMenuModels()].sort((left, right) => {
+            const leftCurrent = this.isCurrentModel(left);
+            const rightCurrent = this.isCurrentModel(right);
+            if (leftCurrent && !rightCurrent)
+                return -1;
+            if (!leftCurrent && rightCurrent)
+                return 1;
+            const providerDelta = left.provider.localeCompare(right.provider);
+            return providerDelta === 0 ? left.id.localeCompare(right.id) : providerDelta;
+        });
+        const items = models.map((model) => {
+            const ref = this.modelRef(model);
+            const current = this.isCurrentModel(model);
+            return {
+                value: { model, ref, current },
+                label: ref,
+                aliases: [model.id, model.name, model.provider],
+                keywords: [model.name, `${model.provider} ${model.id}`],
+            };
+        });
+        return fuzzySearch(items, query).map((match) => ({
+            value: match.value,
+            label: `${match.value.ref}${match.value.current ? ` ${APP_ICONS.check}` : ""}`,
+            description: match.value.model.name,
+        }));
+    }
+    getThinkingMenuItems(query) {
+        const session = this.host.runtime()?.session;
+        const currentLevel = session?.thinkingLevel ?? "off";
+        const availableLevels = session ? session.getAvailableThinkingLevels() : [...THINKING_LEVELS];
+        const levels = availableLevels.includes("off") ? availableLevels : ["off", ...availableLevels];
+        const items = levels.map((level) => ({
+            value: { level, current: level === currentLevel },
+            label: level,
+            keywords: [
+                level === "off" ? "disabled none no reasoning" : "reasoning thinking effort",
+                level === "minimal" ? "fast small" : "",
+                level === "xhigh" ? "extra highest maximum" : "",
+            ].filter(Boolean),
+        }));
+        return fuzzySearch(items, query).map((match) => ({
+            value: match.value,
+            label: `${match.value.level}${match.value.current ? ` ${APP_ICONS.check}` : ""}`,
+            description: this.thinkingLevelDescription(match.value.level),
+        }));
+    }
+    getUserMessageMenuItems() {
+        return [
+            { value: "copy", label: "Copy message", description: "Copy the full user message" },
+            { value: "fork", label: "Fork", description: "Create a new session before this message" },
+            { value: "undo", label: "Undo changes", description: "Revert recorded commands and cut session here" },
+        ];
+    }
+    getUserMessageJumpMenuItems(query) {
+        return buildUserMessageJumpItems(this.host.getEntries(), query);
+    }
+    getQueueMessageMenuItems() {
+        return [
+            { value: "cancel", label: "Cancel send", description: "Remove this message from the queue" },
+            { value: "edit", label: "Edit", description: "Move it back to the editor" },
+            { value: "send-now", label: "Send immediately", description: "Send now and keep the rest queued" },
+        ];
+    }
+    getResumeMenuItems(query, limit) {
+        const sessionFile = this.host.runtime()?.session.sessionFile;
+        const currentSessionFile = sessionFile ? resolve(sessionFile) : undefined;
+        const loader = this.getResumeMenuItemsLoader(currentSessionFile, query);
+        return [
+            { value: { kind: "new" }, label: "new", description: "Create a new session" },
+            ...loader.items(limit).map((item) => ({
+                ...item,
+                value: { kind: "session", session: item.value },
+            })),
+        ];
+    }
+    getResumeMenuItemsLoader(currentSessionFile, query) {
+        const sessions = this.host.getResumeSessions();
+        const cache = this.resumeMenuLoaderCache;
+        if (cache &&
+            cache.sessions === sessions &&
+            cache.currentSessionFile === currentSessionFile &&
+            cache.query === query) {
+            return cache.loader;
+        }
+        const loader = createSessionInfoMenuItemsLoader(sessions, currentSessionFile, query);
+        this.resumeMenuLoaderCache = { sessions, currentSessionFile, query, loader };
+        return loader;
+    }
+    getAllSlashCommands() {
+        return [...this.host.getBuiltinSlashCommands(), ...this.getResourceSlashCommands()];
+    }
+    isCurrentModel(model) {
+        const current = this.host.runtime()?.session.model;
+        return current?.provider === model.provider && current.id === model.id;
+    }
+    resolveScopedModelRefs(modelRefs) {
+        const registry = this.host.runtime()?.services.modelRegistry;
+        if (!registry)
+            return [];
+        registry.refresh();
+        const scopedModels = [];
+        for (const modelRef of modelRefs) {
+            const parsed = parseScopedModelRef(modelRef);
+            if (!parsed)
+                continue;
+            const model = registry.find(parsed.provider, parsed.modelId);
+            if (!model)
+                continue;
+            scopedModels.push({
+                model,
+                ...(parsed.thinkingLevel === undefined ? {} : { thinkingLevel: parsed.thinkingLevel }),
+            });
+        }
+        return scopedModels;
+    }
+    getModelMenuModels() {
+        const session = this.host.runtime()?.session;
+        const scopedModels = session?.scopedModels.length ? session.scopedModels : this.getFavoriteScopedModels();
+        if (!scopedModels.length)
+            return [];
+        const registry = this.host.runtime()?.services.modelRegistry;
+        registry?.refresh();
+        return scopedModels.map((scoped) => {
+            const refreshed = registry?.find(scoped.model.provider, scoped.model.id);
+            return (refreshed ?? scoped.model);
+        });
+    }
+    thinkingLevelDescription(level) {
+        switch (level) {
+            case "off":
+                return "No reasoning/thinking";
+            case "minimal":
+                return "Minimal reasoning";
+            case "low":
+                return "Low reasoning";
+            case "medium":
+                return "Medium reasoning";
+            case "high":
+                return "High reasoning";
+            case "xhigh":
+                return "Extra high reasoning";
+        }
+    }
+}

package/dist/app/message-content.d.ts

@@ -0,0 +1,8 @@
+import type { ImageContent } from "../input-editor.js";
+export declare function stringifyUnknown(value: unknown): string;
+export declare function formatStructuredText(value: unknown): string;
+export declare function renderContent(content: readonly unknown[]): string;
+export declare function renderUserMessageContent(content: unknown): string;
+export declare function extractImageContents(content: unknown): ImageContent[];
+export declare function isImageContent(item: unknown): item is ImageContent;
+export declare function submittedUserDisplayText(displayText: string, promptText: string, images: readonly ImageContent[]): string;

package/dist/app/message-content.js

@@ -0,0 +1,115 @@
+import { isRecord } from "./guards.js";
+export function stringifyUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Error)
+        return value.message || value.name;
+    if (isRecord(value)) {
+        const message = typeof value.message === "string" ? value.message : undefined;
+        const name = typeof value.name === "string" ? value.name : undefined;
+        if (message)
+            return name && name !== "Error" ? `${name}: ${message}` : message;
+        if (name)
+            return name;
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function formatStructuredText(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return "(empty)";
+        try {
+            return JSON.stringify(JSON.parse(trimmed), null, 2);
+        }
+        catch {
+            return value;
+        }
+    }
+    return stringifyUnknown(value);
+}
+export function renderContent(content) {
+    const parts = [];
+    let imageCount = 0;
+    for (const item of content) {
+        if (!isRecord(item)) {
+            parts.push(stringifyUnknown(item));
+            continue;
+        }
+        if (isImageContent(item)) {
+            imageCount += 1;
+            parts.push(imageContentLabel(item, imageCount));
+            continue;
+        }
+        if (typeof item.text === "string") {
+            parts.push(item.text);
+            continue;
+        }
+        if (typeof item.thinking === "string") {
+            parts.push(item.thinking);
+            continue;
+        }
+        parts.push(stringifyUnknown(item));
+    }
+    return parts.join("\n");
+}
+export function renderUserMessageContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return stringifyUnknown(content);
+    const textParts = [];
+    let imageCount = 0;
+    for (const item of content) {
+        if (!isRecord(item)) {
+            textParts.push(stringifyUnknown(item));
+            continue;
+        }
+        if (item.type === "image") {
+            imageCount += 1;
+            continue;
+        }
+        if (typeof item.text === "string") {
+            textParts.push(item.text);
+            continue;
+        }
+        textParts.push(stringifyUnknown(item));
+    }
+    const text = textParts.join("\n").replace(/\[Image \d+(?:: [^\]]+)?\]/g, "").trimEnd();
+    if (imageCount === 0)
+        return text;
+    const imageText = userImageLabels(imageCount);
+    return text ? `${text}\n${imageText}` : imageText;
+}
+export function extractImageContents(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(isImageContent);
+}
+export function isImageContent(item) {
+    return isRecord(item) && item.type === "image" && typeof item.data === "string" && typeof item.mimeType === "string";
+}
+function imageContentLabel(item, index) {
+    const label = index === 1 ? "Image" : `Image ${index}`;
+    return `[${label}: ${item.mimeType}]`;
+}
+function userImageLabels(count) {
+    if (count <= 0)
+        return "";
+    if (count === 1)
+        return "[Image]";
+    return Array.from({ length: count }, (_, index) => `[Image ${index + 1}]`).join("\n");
+}
+export function submittedUserDisplayText(displayText, promptText, images) {
+    const trimmedDisplay = displayText.trimEnd();
+    if (trimmedDisplay)
+        return trimmedDisplay;
+    if (images.length > 0)
+        return userImageLabels(images.length);
+    return promptText.trimEnd();
+}

package/dist/app/model-ref.d.ts

@@ -0,0 +1,13 @@
+import type { ThinkingLevel } from "./types.js";
+export declare function parseModelRef(value: string): {
+    provider: string;
+    modelId: string;
+    thinkingLevel?: ThinkingLevel;
+};
+export declare function parseScopedModelRef(value: string): {
+    provider: string;
+    modelId: string;
+    thinkingLevel?: ThinkingLevel;
+} | undefined;
+export declare function isThinkingLevel(value: string): value is ThinkingLevel;
+export declare function stripProviderFromModelRef(value: string): string;

package/dist/app/model-ref.js

@@ -0,0 +1,50 @@
+import { THINKING_LEVELS } from "./constants.js";
+export function parseModelRef(value) {
+    const [modelPart, thinkingPart] = value.split(":", 2);
+    if (!modelPart)
+        throw new Error("Model reference cannot be empty");
+    const slashIndex = modelPart.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === modelPart.length - 1) {
+        throw new Error("Model must use provider/model format");
+    }
+    let thinkingLevel;
+    if (thinkingPart) {
+        if (!isThinkingLevel(thinkingPart)) {
+            throw new Error(`Unknown thinking level: ${thinkingPart}`);
+        }
+        thinkingLevel = thinkingPart;
+    }
+    return {
+        provider: modelPart.slice(0, slashIndex),
+        modelId: modelPart.slice(slashIndex + 1),
+        ...(thinkingLevel === undefined ? {} : { thinkingLevel }),
+    };
+}
+export function parseScopedModelRef(value) {
+    const slashIndex = value.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === value.length - 1)
+        return undefined;
+    const provider = value.slice(0, slashIndex);
+    let modelId = value.slice(slashIndex + 1);
+    let thinkingLevel;
+    const colonIndex = modelId.lastIndexOf(":");
+    if (colonIndex > 0) {
+        const suffix = modelId.slice(colonIndex + 1);
+        if (isThinkingLevel(suffix)) {
+            modelId = modelId.slice(0, colonIndex);
+            thinkingLevel = suffix;
+        }
+    }
+    return {
+        provider,
+        modelId,
+        ...(thinkingLevel === undefined ? {} : { thinkingLevel }),
+    };
+}
+export function isThinkingLevel(value) {
+    return THINKING_LEVELS.includes(value);
+}
+export function stripProviderFromModelRef(value) {
+    const slashIndex = value.indexOf("/");
+    return slashIndex >= 0 && slashIndex < value.length - 1 ? value.slice(slashIndex + 1) : value;
+}

package/dist/app/model-usage-controller.d.ts

@@ -0,0 +1,35 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { type ModelUsageDescriptor, type ModelUsageStatus } from "./model-usage-status.js";
+export type AppModelUsageQuery = (descriptor: ModelUsageDescriptor) => Promise<ModelUsageStatus | undefined>;
+export type ModelUsageRefreshResult = "refreshed" | "unavailable" | "failed";
+export type ModelUsageRefreshStart = {
+    kind: "started";
+    promise: Promise<ModelUsageRefreshResult>;
+} | {
+    kind: "in-flight";
+} | {
+    kind: "unsupported";
+};
+export type AppModelUsageControllerHost = {
+    runtimeSession(): AgentSession | undefined;
+    render(): void;
+};
+export declare class AppModelUsageController {
+    private readonly host;
+    private readonly queryUsageStatus;
+    private activeModelKey;
+    private readonly statuses;
+    private readonly inFlightModelKeys;
+    private readonly lastAttemptAt;
+    private timer;
+    constructor(host: AppModelUsageControllerHost, queryUsageStatus?: AppModelUsageQuery);
+    startPolling(): void;
+    stopPolling(): void;
+    observeSession(session: AgentSession | undefined): void;
+    statusLabel(): string;
+    refreshNow(): ModelUsageRefreshStart;
+    private tick;
+    private refresh;
+    private syncActiveModel;
+    private activeStatus;
+}

package/dist/app/model-usage-controller.js

@@ -0,0 +1,99 @@
+import { MODEL_USAGE_POLL_INTERVAL_MS, MODEL_USAGE_STATUS_TICK_MS } from "./constants.js";
+import { formatModelUsageStatusLabel, modelUsageDescriptor, queryModelUsageStatus, } from "./model-usage-status.js";
+export class AppModelUsageController {
+    host;
+    queryUsageStatus;
+    activeModelKey;
+    statuses = new Map();
+    inFlightModelKeys = new Set();
+    lastAttemptAt = new Map();
+    timer;
+    constructor(host, queryUsageStatus = queryModelUsageStatus) {
+        this.host = host;
+        this.queryUsageStatus = queryUsageStatus;
+    }
+    startPolling() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            this.tick();
+        }, MODEL_USAGE_STATUS_TICK_MS);
+        this.timer.unref?.();
+        this.tick(true);
+    }
+    stopPolling() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    observeSession(session) {
+        const changed = this.syncActiveModel(session);
+        if (changed && this.activeModelKey)
+            this.refresh();
+    }
+    statusLabel() {
+        return formatModelUsageStatusLabel(this.activeStatus());
+    }
+    refreshNow() {
+        const session = this.host.runtimeSession();
+        this.syncActiveModel(session);
+        const descriptor = modelUsageDescriptor(session?.model);
+        if (!descriptor)
+            return { kind: "unsupported" };
+        const promise = this.refresh(true, descriptor);
+        return promise ? { kind: "started", promise } : { kind: "in-flight" };
+    }
+    tick(force = false) {
+        this.syncActiveModel(this.host.runtimeSession());
+        const descriptor = modelUsageDescriptor(this.host.runtimeSession()?.model);
+        if (!descriptor)
+            return;
+        const lastAttemptAt = this.lastAttemptAt.get(descriptor.modelKey) ?? 0;
+        if (force || Date.now() - lastAttemptAt >= MODEL_USAGE_POLL_INTERVAL_MS) {
+            this.refresh(force, descriptor);
+            return;
+        }
+        if (this.activeStatus())
+            this.host.render();
+    }
+    refresh(force = false, activeDescriptor) {
+        const descriptor = activeDescriptor ?? modelUsageDescriptor(this.host.runtimeSession()?.model);
+        if (!descriptor)
+            return undefined;
+        const modelKey = descriptor.modelKey;
+        if (this.inFlightModelKeys.has(modelKey))
+            return undefined;
+        const lastAttemptAt = this.lastAttemptAt.get(modelKey) ?? 0;
+        if (!force && Date.now() - lastAttemptAt < MODEL_USAGE_POLL_INTERVAL_MS)
+            return undefined;
+        this.inFlightModelKeys.add(modelKey);
+        this.lastAttemptAt.set(modelKey, Date.now());
+        return this.queryUsageStatus(descriptor).then((status) => {
+            if (status) {
+                this.statuses.set(modelKey, status);
+                return "refreshed";
+            }
+            this.statuses.delete(modelKey);
+            return "unavailable";
+        }, () => {
+            // Keep the previous value for this model on transient network/auth failures.
+            return "failed";
+        }).finally(() => {
+            this.inFlightModelKeys.delete(modelKey);
+            if (this.activeModelKey === modelKey)
+                this.host.render();
+        });
+    }
+    syncActiveModel(session) {
+        const nextModelKey = modelUsageDescriptor(session?.model)?.modelKey;
+        if (nextModelKey === this.activeModelKey)
+            return false;
+        this.activeModelKey = nextModelKey;
+        this.host.render();
+        return true;
+    }
+    activeStatus() {
+        return this.activeModelKey ? this.statuses.get(this.activeModelKey) : undefined;
+    }
+}

package/dist/app/model-usage-status.d.ts

@@ -0,0 +1,125 @@
+import type { SessionModel } from "./types.js";
+type BaseModelUsageDescriptor = {
+    readonly modelKey: string;
+};
+export type ModelUsageDescriptor = BaseModelUsageDescriptor & ({
+    readonly kind: "openai" | "zhipu";
+} | {
+    readonly kind: "google-antigravity";
+    readonly quotaModelKey: string;
+    readonly account: AntigravityQuotaAccount;
+});
+export type ModelUsageLimitWindow = {
+    readonly remainingPercent: number;
+    readonly resetAt: number;
+    readonly windowSeconds: number;
+};
+export type ModelUsageStatus = {
+    readonly modelKey: string;
+    readonly provider: "openai" | "zhipu" | "google-antigravity";
+    readonly updatedAt: number;
+    readonly accountEmail?: string;
+    readonly weekly?: ModelUsageLimitWindow;
+    readonly hourly?: ModelUsageLimitWindow;
+};
+type RateLimitWindow = {
+    used_percent: number;
+    limit_window_seconds: number;
+    reset_after_seconds: number;
+};
+type OpenAIRateLimit = {
+    allowed?: boolean;
+    limit_reached: boolean;
+    primary_window: RateLimitWindow;
+    secondary_window: RateLimitWindow | null;
+};
+type OpenAIAdditionalRateLimit = {
+    limit_name: string;
+    metered_feature?: string;
+    rate_limit: OpenAIRateLimit | null;
+};
+export type AccountUsageLimitWindow = {
+    readonly label: string;
+    readonly remainingPercent: number;
+    readonly resetAt: number;
+    readonly windowSeconds: number;
+    readonly used?: number;
+    readonly limit?: number;
+};
+export type AccountUsageReport = {
+    readonly openai?: {
+        readonly account: string;
+        readonly planType?: string;
+        readonly windows: readonly AccountUsageLimitWindow[];
+        readonly limitReached: boolean;
+        readonly additionalLimits?: readonly {
+            readonly name: string;
+            readonly meteredFeature?: string;
+            readonly windows: readonly AccountUsageLimitWindow[];
+            readonly limitReached: boolean;
+        }[];
+        readonly error?: string;
+    };
+    readonly zai?: {
+        readonly account: string;
+        readonly windows: readonly AccountUsageLimitWindow[];
+        readonly mcp?: AccountUsageLimitWindow;
+        readonly error?: string;
+    };
+    readonly googleAccounts: readonly {
+        readonly account: string;
+        readonly windows: readonly AccountUsageLimitWindow[];
+        readonly limitReached: boolean;
+        readonly error?: string;
+    }[];
+    readonly generatedAt: number;
+};
+export type OpenAIUsageResponse = {
+    plan_type: string;
+    rate_limit: OpenAIRateLimit | null;
+    additional_rate_limits?: OpenAIAdditionalRateLimit[];
+};
+type AntigravityQuotaAccount = {
+    readonly email?: string;
+    readonly refreshToken: string;
+    readonly projectId: string;
+    readonly accountIndex?: number;
+    readonly accountCount?: number;
+    readonly cacheKey: string;
+};
+type GoogleQuotaResponse = {
+    models: Record<string, {
+        quotaInfo?: {
+            remainingFraction?: number;
+            resetTime?: string;
+        };
+    }>;
+};
+export declare function modelUsageDescriptor(model: SessionModel | undefined): ModelUsageDescriptor | undefined;
+export declare function queryModelUsageStatus(descriptor: ModelUsageDescriptor): Promise<ModelUsageStatus | undefined>;
+export declare function queryAccountUsageReport(now?: number): Promise<AccountUsageReport>;
+export declare function formatAccountUsageReport(report: AccountUsageReport, now?: number): string;
+export declare function formatModelUsageStatusLabel(status: ModelUsageStatus | undefined, now?: number): string;
+export declare function modelUsageRemainingPercent(status: ModelUsageStatus | undefined): number | undefined;
+export declare function openAIUsageStatusFromResponse(data: OpenAIUsageResponse, modelKey: string, now?: number): ModelUsageStatus | undefined;
+type ZhipuUsageLimitItem = {
+    type: string;
+    usage: number;
+    currentValue: number;
+    percentage: number;
+    nextResetTime?: number;
+};
+type ZhipuQuotaResponse = {
+    code: number;
+    msg: string;
+    data: {
+        limits: ZhipuUsageLimitItem[];
+    };
+    success: boolean;
+};
+export declare function zhipuUsageStatusFromResponse(data: ZhipuQuotaResponse, modelKey: string, now?: number): ModelUsageStatus | undefined;
+export declare function resolveAntigravityQuotaModelKey(model: SessionModel): string | undefined;
+export declare function googleAntigravityUsageStatusFromResponse(data: GoogleQuotaResponse, descriptor: Extract<ModelUsageDescriptor, {
+    kind: "google-antigravity";
+}>, now?: number): ModelUsageStatus | undefined;
+export {};