@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/integrations/pi/engine/workflow-support.js

@@ -0,0 +1,352 @@
+/** Pure helpers behind pinned Pi's workflows: result wording, session-info presentation, model matching, and option shaping. */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readPinnedCommandChangelog } from "./changelog.js";
+import { dynamicObject, finiteNumber, isRecord, stringProperty, stringValue } from "./message-values.js";
+import { copyToClipboard } from "../startup-public.js";
+const execFileAsync = promisify(execFile);
+export const AUTH_REFRESH_TIMEOUT_MS = 15_000;
+// Provenance: Pi 0.84.2 core/model-resolver.ts defaultModelPerProvider.
+export const PINNED_DEFAULT_MODEL_BY_PROVIDER = Object.freeze({
+    "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
+    "ant-ling": "Ring-2.6-1T",
+    anthropic: "claude-opus-4-8",
+    openai: "gpt-5.5",
+    "azure-openai-responses": "gpt-5.4",
+    "openai-codex": "gpt-5.5",
+    radius: "auto",
+    nvidia: "nvidia/nemotron-3-super-120b-a12b",
+    deepseek: "deepseek-v4-pro",
+    google: "gemini-3.1-pro-preview",
+    "google-vertex": "gemini-3.1-pro-preview",
+    "github-copilot": "gpt-5.4",
+    openrouter: "moonshotai/kimi-k2.6",
+    "vercel-ai-gateway": "zai/glm-5.1",
+    xai: "grok-4.5",
+    groq: "openai/gpt-oss-120b",
+    cerebras: "zai-glm-4.7",
+    zai: "glm-5.1",
+    "zai-coding-cn": "glm-5.1",
+    mistral: "devstral-medium-latest",
+    minimax: "MiniMax-M2.7",
+    "minimax-cn": "MiniMax-M2.7",
+    moonshotai: "kimi-k2.6",
+    "moonshotai-cn": "kimi-k2.6",
+    huggingface: "moonshotai/Kimi-K2.6",
+    fireworks: "accounts/fireworks/models/kimi-k2p6",
+    together: "moonshotai/Kimi-K2.6",
+    baseten: "zai-org/GLM-5.2",
+    opencode: "kimi-k2.6",
+    "opencode-go": "kimi-k2.6",
+    "kimi-coding": "kimi-for-coding",
+    "cloudflare-workers-ai": "@cf/moonshotai/kimi-k2.6",
+    "cloudflare-ai-gateway": "workers-ai/@cf/moonshotai/kimi-k2.6",
+    "qwen-token-plan": "qwen3.7-max",
+    "qwen-token-plan-cn": "qwen3.7-max",
+    "qwen-token-plan-individual": "qwen3.8-max",
+    xiaomi: "mimo-v2.5-pro",
+    "xiaomi-token-plan-cn": "mimo-v2.5-pro",
+    "xiaomi-token-plan-ams": "mimo-v2.5-pro",
+    "xiaomi-token-plan-sgp": "mimo-v2.5-pro",
+});
+export function pinnedSessionInfoPresentation(value, sessionName, entries, modelRuntime) {
+    const stats = isRecord(value) ? value : {};
+    const tokens = dynamicObject(stats, "tokens");
+    return {
+        kind: "session-info",
+        ...(sessionName === undefined ? {} : { sessionName }),
+        stats: {
+            ...(stringProperty(stats, "sessionFile") === undefined ? {} : { sessionFile: stringProperty(stats, "sessionFile") }),
+            sessionId: stringProperty(stats, "sessionId") ?? "unknown",
+            userMessages: finiteNumber(stats.userMessages),
+            assistantMessages: finiteNumber(stats.assistantMessages),
+            toolCalls: finiteNumber(stats.toolCalls),
+            toolResults: finiteNumber(stats.toolResults),
+            totalMessages: finiteNumber(stats.totalMessages),
+            tokens: {
+                input: finiteNumber(tokens.input),
+                output: finiteNumber(tokens.output),
+                cacheRead: finiteNumber(tokens.cacheRead),
+                cacheWrite: finiteNumber(tokens.cacheWrite),
+                total: finiteNumber(tokens.total),
+            },
+            cost: finiteNumber(stats.cost),
+        },
+        cacheWaste: pinnedCacheWaste(entries, modelRuntime),
+        usageBreakdown: pinnedUsageCostBreakdown(entries),
+    };
+}
+export function pinnedUsageCostBreakdown(entries) {
+    const totals = new Map();
+    for (const entry of entries) {
+        if (!isRecord(entry))
+            continue;
+        let key;
+        let usage;
+        const message = dynamicObject(entry, "message");
+        if (entry.type === "message" && message.role === "assistant") {
+            const provider = stringProperty(message, "provider");
+            const model = stringProperty(message, "responseModel") ?? stringProperty(message, "model");
+            if (provider && model)
+                key = `${provider}/${model}`;
+            usage = dynamicObject(message, "usage");
+        }
+        else if (entry.type === "message" && message.role === "toolResult" && isRecord(message.usage)) {
+            key = "Tools/summaries";
+            usage = message.usage;
+        }
+        else if ((entry.type === "branch_summary" || entry.type === "compaction") && isRecord(entry.usage)) {
+            key = "Tools/summaries";
+            usage = entry.usage;
+        }
+        if (!key || !usage)
+            continue;
+        const cost = finiteNumber(dynamicObject(usage, "cost").total);
+        const tokens = finiteNumber(usage.input) + finiteNumber(usage.output)
+            + finiteNumber(usage.cacheRead) + finiteNumber(usage.cacheWrite);
+        const current = totals.get(key) ?? { cost: 0, tokens: 0 };
+        current.cost += cost;
+        current.tokens += tokens;
+        totals.set(key, current);
+    }
+    return [...totals].map(([key, total]) => ({ key, ...total }))
+        .filter(entry => entry.cost > 0 || entry.tokens > 0)
+        .sort((a, b) => b.cost - a.cost);
+}
+export function pinnedCacheWaste(entries, modelRuntime) {
+    let previous;
+    const totals = { missedTokens: 0, missedCost: 0, missCount: 0 };
+    for (const entry of entries) {
+        if (!isRecord(entry))
+            continue;
+        if (entry.type === "compaction" || entry.type === "branch_summary") {
+            previous = undefined;
+            continue;
+        }
+        const message = dynamicObject(entry, "message");
+        if (entry.type !== "message" || message.role !== "assistant")
+            continue;
+        const usage = dynamicObject(message, "usage");
+        const input = finiteNumber(usage.input);
+        const cacheRead = finiteNumber(usage.cacheRead);
+        const cacheWrite = finiteNumber(usage.cacheWrite);
+        const promptTokens = input + cacheRead + cacheWrite;
+        if (previous && promptTokens > 0 && (cacheRead + cacheWrite > 0 || previous.reportedCache)) {
+            const missedTokens = Math.min(previous.promptTokens, promptTokens) - cacheRead;
+            if (missedTokens > 1024) {
+                const cost = dynamicObject(usage, "cost");
+                const paidTokens = input + cacheWrite;
+                const paidRate = paidTokens > 0 ? (finiteNumber(cost.input) + finiteNumber(cost.cacheWrite)) / paidTokens : 0;
+                const provider = stringProperty(message, "provider") ?? "";
+                const modelId = stringProperty(message, "model") ?? "";
+                const model = modelRuntime.getModel(provider, modelId);
+                const modelCost = dynamicObject(dynamicObject(model, "cost"));
+                const readRate = cacheRead > 0
+                    ? finiteNumber(cost.cacheRead) / cacheRead
+                    : finiteNumber(modelCost.cacheRead) / 1_000_000;
+                totals.missedTokens += missedTokens;
+                totals.missedCost += missedTokens * Math.max(0, paidRate - readRate);
+                totals.missCount += 1;
+            }
+        }
+        if (promptTokens > 0) {
+            const provider = stringProperty(message, "provider") ?? "";
+            const model = stringProperty(message, "model") ?? "";
+            previous = {
+                promptTokens,
+                modelKey: `${provider}/${model}`,
+                timestamp: finiteNumber(message.timestamp),
+                reportedCache: (previous?.reportedCache ?? false) || cacheRead + cacheWrite > 0,
+            };
+        }
+    }
+    return totals;
+}
+export function defaultWorkflowHost() {
+    return {
+        copyText: copyToClipboard,
+        async runCommand(command, arguments_, options) {
+            const result = await execFileAsync(command, [...arguments_], { encoding: "utf8", signal: options?.signal });
+            return { stdout: result.stdout, stderr: result.stderr };
+        },
+        readChangelog: readPinnedCommandChangelog,
+    };
+}
+export function workflowLoginNotification(event) {
+    if (!isRecord(event))
+        return undefined;
+    if (event.type === "auth_url") {
+        const url = stringProperty(event, "url");
+        if (!url)
+            return undefined;
+        const instructions = stringProperty(event, "instructions");
+        return { type: "auth_url", url, ...(instructions === undefined ? {} : { instructions }) };
+    }
+    if (event.type === "device_code") {
+        const verificationUri = stringProperty(event, "verificationUri");
+        const userCode = stringProperty(event, "userCode");
+        return verificationUri && userCode ? { type: "device_code", verificationUri, userCode } : undefined;
+    }
+    const message = stringProperty(event, "message");
+    if (!message)
+        return undefined;
+    if (event.type === "info") {
+        const links = Array.isArray(event.links) ? event.links.filter(isRecord).flatMap(link => {
+            const url = stringProperty(link, "url");
+            if (!url)
+                return [];
+            const label = stringProperty(link, "label");
+            return [{ ...(label === undefined ? {} : { label }), url }];
+        }) : [];
+        return { type: "info", message, ...(links.length === 0 ? {} : { links }) };
+    }
+    return { type: event.type === "waiting" ? "waiting" : "progress", message };
+}
+export function workflowResult(command, outcome, message, detail, messageKind, messages) {
+    return {
+        command,
+        outcome,
+        message,
+        ...(detail === undefined ? {} : { detail }),
+        ...(messageKind === undefined ? {} : { messageKind }),
+        ...(messages === undefined ? {} : { messages: Object.freeze([...messages]) }),
+    };
+}
+export function workflowConfirmation(command, message, detail) {
+    return {
+        command,
+        outcome: "requires-confirmation",
+        message,
+        ...(detail === undefined ? {} : { detail }),
+        selectorTitle: "Confirm",
+        options: [
+            { id: "yes", label: "Yes" },
+            { id: "no", label: "No" },
+        ],
+    };
+}
+export function errorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+export function shareCommandFailureDetail(error) {
+    // Compatibility: Pi reports a failed child's stderr, not execFile's command wrapper.
+    if (isRecord(error) && (typeof error.code === "number" || typeof error.signal === "string") && typeof error.stderr === "string") {
+        return error.stderr.trim() || "Unknown error";
+    }
+    return errorMessage(error, "Unknown error");
+}
+export function commandMissing(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}
+export function isAbortError(error) {
+    return isRecord(error) && (error.name === "AbortError" || error.code === "ABORT_ERR");
+}
+export function shareViewerUrl(gistId) {
+    const baseUrl = process.env.PI_SHARE_VIEWER_URL || "https://pi.dev/session/";
+    return `${baseUrl}#${gistId}`;
+}
+export function workflowOptions(value, idKey, labelKey) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isRecord).flatMap(item => {
+        const id = stringProperty(item, idKey);
+        if (!id)
+            return [];
+        return [{ id, label: stringProperty(item, labelKey) ?? id }];
+    });
+}
+export function sessionInfoOptions(value) {
+    return value.filter(isRecord).flatMap(info => {
+        const path = stringProperty(info, "path");
+        if (!path)
+            return [];
+        const modified = info.modified instanceof Date ? info.modified.toISOString() : stringProperty(info, "modified") ?? "unknown time";
+        const messageCount = typeof info.messageCount === "number" ? info.messageCount : 0;
+        return [{
+                id: path,
+                label: stringProperty(info, "name") ?? stringProperty(info, "firstMessage") ?? stringProperty(info, "id") ?? path,
+                description: `${messageCount} messages · ${modified}`,
+            }];
+    });
+}
+export function pathArgument(value) {
+    if (!value)
+        return undefined;
+    const quote = value[0];
+    if (quote === '"' || quote === "'") {
+        const closing = value.indexOf(quote, 1);
+        return closing < 0 ? undefined : value.slice(1, closing);
+    }
+    return value.split(/\s/, 1)[0] || undefined;
+}
+export function pinnedHotkeySummary() {
+    return [
+        "Enter: send message · Alt+Enter: queue follow-up",
+        "Escape: cancel/abort · Ctrl+C: clear/exit · Ctrl+D: exit when empty",
+        "Shift+Tab: cycle thinking · Ctrl+P/Shift+Ctrl+P: cycle models · Ctrl+L: select model",
+        "Ctrl+O: expand tools · Ctrl+T: toggle thinking · Ctrl+X: copy message",
+        "Alt+Up: restore queued messages · /: commands · !/!!: bash",
+    ].join("\n");
+}
+export function scopedModelRecords(modelRuntime) {
+    return modelRuntime.getAvailableSnapshot().map(model => ({
+        descriptor: { provider: model.provider, id: model.id, name: model.name ?? model.id },
+        model,
+    }));
+}
+export function scopedModelReference(value) {
+    if (!isRecord(value) || !isRecord(value.model))
+        return undefined;
+    const provider = stringValue(value.model.provider);
+    const id = stringValue(value.model.id);
+    return provider && id ? `${provider}/${id}` : undefined;
+}
+export function resolveConfiguredModelIds(patterns, models) {
+    const references = models.map(item => `${item.descriptor.provider}/${item.descriptor.id}`);
+    const resolved = [];
+    for (const pattern of patterns) {
+        const thinkingSuffix = /:(?:off|minimal|low|medium|high|xhigh)$/.exec(pattern);
+        const modelPattern = thinkingSuffix === null ? pattern : pattern.slice(0, -thinkingSuffix[0].length);
+        const matcher = wildcardMatcher(modelPattern);
+        const matches = references.filter((reference, index) => matcher.test(reference) || matcher.test(models[index]?.descriptor.id ?? ""));
+        if (matches.length === 0) {
+            resolved.push(pattern);
+        }
+        else {
+            for (const match of matches)
+                if (!resolved.includes(match))
+                    resolved.push(match);
+        }
+    }
+    return resolved;
+}
+export function wildcardMatcher(pattern) {
+    let source = "";
+    for (const character of pattern) {
+        if (character === "*")
+            source += ".*";
+        else if (character === "?")
+            source += ".";
+        else
+            source += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    }
+    return new RegExp(`^${source}$`, "i");
+}
+export function isUnknownModel(value) {
+    return isRecord(value)
+        && value.provider === "unknown"
+        && value.id === "unknown"
+        && value.api === "unknown";
+}
+export function findExactWorkflowModel(reference, models) {
+    const normalized = reference.trim().toLowerCase();
+    const canonical = models.filter(model => {
+        const provider = stringProperty(model, "provider");
+        const id = stringProperty(model, "id");
+        return provider !== undefined && id !== undefined && `${provider}/${id}`.toLowerCase() === normalized;
+    });
+    if (canonical.length === 1)
+        return canonical[0];
+    const bare = models.filter(model => stringProperty(model, "id")?.toLowerCase() === normalized);
+    return bare.length === 1 ? bare[0] : undefined;
+}

package/dist/integrations/pi/engine/workflows.d.ts

@@ -0,0 +1,275 @@
+import type { SessionInfo } from "../startup-public.js";
+export declare const PINNED_PI_WORKFLOW_COMMAND_NAMES: readonly ["settings", "model", "tree", "thinking", "scoped-models", "export", "import", "share", "copy", "name", "session", "changelog", "hotkeys", "fork", "clone", "trust", "login", "logout", "new", "compact", "resume", "reload", "quit"];
+export declare const PINNED_PI_HIDDEN_COMMAND_NAMES: readonly ["debug", "arminsayshi", "dementedelves"];
+export type PiWorkflowCommandName = typeof PINNED_PI_WORKFLOW_COMMAND_NAMES[number];
+export type PiHiddenWorkflowCommandName = typeof PINNED_PI_HIDDEN_COMMAND_NAMES[number];
+/** The one bare-A1 model command; it replaces the pinned `model` and `scoped-models` routes there. */
+export declare const OWNED_MODELS_COMMAND_NAME: "models";
+export type OwnedModelsCommandName = typeof OWNED_MODELS_COMMAND_NAME;
+export type OwnedWorkflowCommandName = Exclude<PiWorkflowCommandName, "model" | "scoped-models"> | OwnedModelsCommandName;
+/** Bare A1's advertised command catalog: the pinned catalog with `models` in place of `model` and `scoped-models`. */
+export declare const OWNED_WORKFLOW_COMMAND_NAMES: readonly OwnedWorkflowCommandName[];
+export type PiProductMode = "bare" | "comparison";
+/** The advertised command catalog for a product mode; hidden routes are shared by both. */
+export declare function workflowCommandNames(productMode: PiProductMode): readonly (PiWorkflowCommandName | OwnedModelsCommandName)[];
+export type PiWorkflowRoute = PiWorkflowCommandName | PiHiddenWorkflowCommandName | OwnedModelsCommandName;
+export declare const PINNED_PI_SETTINGS_CALLBACKS: readonly ["onAutoCompactChange", "onShowImagesChange", "onImageWidthCellsChange", "onAutoResizeImagesChange", "onBlockImagesChange", "onEnableSkillCommandsChange", "onSteeringModeChange", "onFollowUpModeChange", "onTransportChange", "onHttpIdleTimeoutMsChange", "onModelThinkingLevelChange", "onModelThinkingLevelRemove", "onThemeChange", "onThemePreview", "onHideThinkingBlockChange", "onMermaidRenderingModeChange", "onShowCacheMissNoticesChange", "onCollapseChangelogChange", "onEnableInstallTelemetryChange", "onQuietStartupChange", "onDefaultProjectTrustChange", "onDoubleEscapeActionChange", "onTreeFilterModeChange", "onShowHardwareCursorChange", "onEditorPaddingXChange", "onOutputPadChange", "onAutocompleteMaxVisibleChange", "onClearOnShrinkChange", "onShowTerminalProgressChange", "onTuiModeChange", "onFullscreenExitOutputChange", "onFullscreenScrollbarChange", "onFullscreenCopyOnSelectChange", "onWarningsChange", "onCancel"];
+export type PiPinnedSettingsCallback = typeof PINNED_PI_SETTINGS_CALLBACKS[number];
+export interface PiPinnedSettingsSnapshot {
+    readonly autoCompact: boolean;
+    readonly showImages: boolean;
+    readonly imageWidthCells: number;
+    readonly autoResizeImages: boolean;
+    readonly blockImages: boolean;
+    readonly enableSkillCommands: boolean;
+    readonly steeringMode: "all" | "one-at-a-time";
+    readonly followUpMode: "all" | "one-at-a-time";
+    readonly transport: "sse" | "websocket" | "websocket-cached" | "auto";
+    readonly httpIdleTimeoutMs: number;
+    readonly thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    readonly availableThinkingLevels: readonly ("off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max")[];
+    /** The stored global default the selector offers to restore; the session's level may differ. */
+    readonly defaultThinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /** Per-model thinking overrides keyed `provider/modelId`. */
+    readonly modelThinkingLevels: Readonly<Record<string, string>>;
+    /** `provider/modelId` of the persisted default model, or the engine's "not set" wording. */
+    readonly defaultModel: string;
+    readonly currentModel?: unknown;
+    readonly availableDefaultModels: readonly unknown[];
+    readonly currentTheme: string;
+    readonly terminalTheme: "dark" | "light";
+    readonly availableThemes: readonly string[];
+    readonly hideThinkingBlock: boolean;
+    readonly mermaidRenderingMode: "off" | "final" | "streaming";
+    readonly showCacheMissNotices: boolean;
+    readonly collapseChangelog: boolean;
+    readonly enableInstallTelemetry: boolean;
+    readonly doubleEscapeAction: "fork" | "tree" | "none";
+    readonly treeFilterMode: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+    readonly showHardwareCursor: boolean;
+    readonly editorPaddingX: number;
+    readonly outputPad: 0 | 1;
+    readonly autocompleteMaxVisible: number;
+    readonly quietStartup: boolean;
+    readonly defaultProjectTrust: "ask" | "always" | "never";
+    readonly clearOnShrink: boolean;
+    readonly showTerminalProgress: boolean;
+    readonly tuiMode: "regular" | "fullscreen";
+    readonly fullscreenExitOutput: "transcript" | "resume-hint";
+    readonly fullscreenScrollbar: "hidden" | "auto" | "always";
+    readonly fullscreenCopyOnSelect: boolean;
+    readonly warnings: {
+        readonly anthropicExtraUsage?: boolean;
+    };
+}
+export interface PiWorkflowOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+}
+export interface PiAuthenticationProviderStatus {
+    readonly type: "oauth" | "api_key";
+    readonly source?: string;
+}
+export interface PiAuthenticationProviderOption extends PiWorkflowOption {
+    readonly providerId: string;
+    readonly authType: "oauth" | "api_key";
+    readonly status?: PiAuthenticationProviderStatus;
+}
+export interface PiWorkflowRequest {
+    readonly command: PiWorkflowRoute;
+    readonly argument: string;
+    readonly selection?: string;
+    /** For the model route: also persist the selection as the default model. The bare `models` route always persists. */
+    readonly persist?: boolean;
+    readonly confirmed?: boolean;
+    /** Recovery cwd selected after an import/resume source cwd is unavailable. */
+    readonly cwdOverride?: string;
+    /** Cancellation for an owned operation surface such as `/share`. */
+    readonly signal?: AbortSignal;
+    readonly treeSummary?: {
+        readonly summarize: boolean;
+        readonly customInstructions?: string;
+    };
+}
+export type PiWorkflowOutcome = "completed" | "cancelled" | "failed" | "requires-selection" | "requires-confirmation";
+export interface PiSessionInfoPresentation {
+    readonly kind: "session-info";
+    readonly sessionName?: string;
+    readonly stats: {
+        readonly sessionFile?: string;
+        readonly sessionId: string;
+        readonly userMessages: number;
+        readonly assistantMessages: number;
+        readonly toolCalls: number;
+        readonly toolResults: number;
+        readonly totalMessages: number;
+        readonly tokens: {
+            readonly input: number;
+            readonly output: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+            readonly total: number;
+        };
+        readonly cost: number;
+    };
+    readonly cacheWaste: {
+        readonly missedTokens: number;
+        readonly missedCost: number;
+        readonly missCount: number;
+    };
+    readonly usageBreakdown: readonly {
+        readonly key: string;
+        readonly cost: number;
+        readonly tokens: number;
+    }[];
+}
+export type PiWorkflowPresentation = PiSessionInfoPresentation;
+export type PiWorkflowMessageKind = "status" | "warning" | "error" | "accent" | "silent";
+export interface PiWorkflowMessage {
+    readonly kind: Exclude<PiWorkflowMessageKind, "silent">;
+    readonly message: string;
+}
+export interface PiWorkflowResult {
+    readonly command: PiWorkflowRoute;
+    readonly outcome: PiWorkflowOutcome;
+    readonly message: string;
+    /** Explicit presentation semantics; never inferred from message prefixes. */
+    readonly messageKind?: PiWorkflowMessageKind;
+    /** Ordered messages for truthful partial-success outcomes. */
+    readonly messages?: readonly PiWorkflowMessage[];
+    readonly detail?: string;
+    readonly selectorTitle?: string;
+    readonly options?: readonly PiWorkflowOption[];
+    readonly presentation?: PiWorkflowPresentation;
+}
+export interface PiWorkflowAutocompleteCommand {
+    readonly name: string;
+    readonly description?: string;
+    readonly argumentHint?: string;
+    readonly argumentOptions?: readonly PiWorkflowOption[];
+    readonly source: "builtin" | "prompt" | "skill" | "extension";
+}
+export interface PiWorkflowInteractionRequest {
+    readonly type: "text" | "secret" | "manual-code" | "select";
+    readonly message: string;
+    readonly placeholder?: string;
+    readonly options?: readonly {
+        readonly id: string;
+        readonly label: string;
+    }[];
+}
+export interface PiWorkflowLoginStart {
+    readonly providerId: string;
+    readonly providerName: string;
+    readonly authType: "oauth" | "api_key";
+}
+export type PiWorkflowLoginNotification = {
+    readonly type: "auth_url";
+    readonly url: string;
+    readonly instructions?: string;
+} | {
+    readonly type: "device_code";
+    readonly verificationUri: string;
+    readonly userCode: string;
+} | {
+    readonly type: "info";
+    readonly message: string;
+    readonly links?: readonly {
+        readonly label?: string;
+        readonly url: string;
+    }[];
+} | {
+    readonly type: "waiting" | "progress";
+    readonly message: string;
+};
+export interface PiWorkflowInteractionHost {
+    startLogin?(request: PiWorkflowLoginStart): void;
+    prompt(request: PiWorkflowInteractionRequest): Promise<string | null>;
+    notify(event: PiWorkflowLoginNotification): void;
+    /** Deliver a post-login status or warning after the authentication dialog closes. */
+    publish?(message: PiWorkflowMessage): void;
+    finishLogin?(): void;
+}
+export interface PiWorkflowHost {
+    copyText(text: string): Promise<void>;
+    runCommand(command: string, arguments_: readonly string[], options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<{
+        readonly stdout: string;
+        readonly stderr: string;
+    }>;
+    readChangelog(sinceVersion?: string): Promise<string>;
+}
+export interface PiBashWorkflowResult {
+    readonly command: string;
+    readonly output: string;
+    readonly exitCode: number | undefined;
+    readonly cancelled: boolean;
+    readonly truncated: boolean;
+    readonly excludeFromContext: boolean;
+}
+export interface PiScopedModelDescriptor {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+}
+export interface PiScopedModelsContext {
+    readonly models: readonly PiScopedModelDescriptor[];
+    readonly enabledModelIds: readonly string[] | null;
+}
+export interface PiProjectTrustUpdate {
+    readonly path: string;
+    readonly decision: boolean | null;
+}
+export interface PiProjectTrustContext {
+    readonly cwd: string;
+    readonly savedDecision: {
+        readonly path: string;
+        readonly decision: boolean;
+    } | null;
+    readonly projectTrusted: boolean;
+    readonly trustOptions: readonly {
+        readonly label: string;
+        readonly trusted: boolean;
+        readonly updates: readonly PiProjectTrustUpdate[];
+        readonly savedPath?: string;
+    }[];
+}
+export interface PiTreeSelectorContext {
+    readonly tree: readonly unknown[];
+    readonly currentLeafId: string | null;
+    readonly filterMode: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+    readonly skipSummaryPrompt: boolean;
+    readonly appendLabelChange: (entryId: string, label: string | undefined) => void;
+}
+export interface PiSessionResumeMetadata {
+    readonly sessionId: string;
+    readonly sessionDir: string;
+    readonly usesDefaultSessionDir: boolean;
+}
+export interface PiSessionSelectorContext {
+    readonly currentSessionFilePath: string | undefined;
+    readonly loadCurrentSessions: (onProgress?: (loaded: number, total: number) => void) => Promise<SessionInfo[]>;
+    readonly loadAllSessions: (onProgress?: (loaded: number, total: number) => void) => Promise<SessionInfo[]>;
+    readonly renameSession: (sessionFilePath: string, nextName: string | undefined) => Promise<void>;
+}
+export interface PiScopedModelsRefreshResult extends PiScopedModelsContext {
+    readonly status: string;
+    readonly statusKind: "success" | "warning";
+}
+/** What the bare-A1 Models dialog reads: the authenticated catalog and the explicit session and persisted scopes, kept apart. */
+export interface PiModelsContext {
+    readonly models: readonly PiScopedModelDescriptor[];
+    /** `provider/id` of the active model, or null before one is set. */
+    readonly activeModelId: string | null;
+    /** Ordered `provider/id` references the session cycles; empty is the all-model fallback, not an explicit full scope. */
+    readonly sessionScopeIds: readonly string[];
+    /** The persisted `enabledModels` patterns resolved against the catalog, in order; unmatched patterns stay verbatim. */
+    readonly persistedScopeIds: readonly string[];
+}
+export interface PiModelsRefreshResult {
+    readonly models: readonly PiScopedModelDescriptor[];
+    readonly status: string;
+    readonly statusKind: "success" | "warning";
+}