import type { AgentRuntimeId } from "./agentRuntime.js";
export type { AgentRuntimeCapability, AgentRuntimeDescriptor, AgentRuntimeDriverKind, AgentRuntimeId, AgentRuntimesResponse, } from "./agentRuntime.js";
export type MachineKind = "local" | "remote";
export type MachineStatus = "unknown" | "online" | "offline" | "error";
export declare const PI_WEB_CAPABILITIES: {
    readonly sessionsDeleteArchived: "sessions.deleteArchived";
    readonly sessionsBulkMutations: "sessions.bulkMutations";
    readonly sessionsCleanup: "sessions.cleanup";
    readonly sessionsReload: "sessions.reload";
    readonly sessionsClearQueue: "sessions.clearQueue";
    readonly sessionsPersistedState: "sessions.persistedState";
    readonly sessionsNotifications: "sessions.notifications";
    readonly sessionsUnread: "sessions.unread";
    readonly promptAttachments: "prompt.attachments";
    readonly workspaceFileSuggestions: "workspace.fileSuggestions";
    readonly piPackagesManage: "piPackages.manage";
    readonly selectedMachineSettings: "settings.selectedMachine";
    readonly agentProfileConfig: "settings.agentProfile";
};
export type PiWebCapability = (typeof PI_WEB_CAPABILITIES)[keyof typeof PI_WEB_CAPABILITIES];
export interface Machine {
    id: string;
    name: string;
    kind: MachineKind;
    baseUrl?: string;
    createdAt: string;
    updatedAt: string;
    status?: MachineStatus;
    statusMessage?: string;
}
export interface MachineHealth {
    machineId: string;
    ok: boolean;
    checkedAt: string;
    status?: MachineStatus;
    web?: PiWebComponentStatus;
    sessiond?: PiWebComponentStatus;
    error?: string;
}
export interface MachineRuntime {
    machineId: string;
    ok: boolean;
    checkedAt: string;
    packageName?: string;
    generatedAt?: string;
    components?: PiWebRuntimeResponse["components"];
    capabilities?: PiWebCapability[];
    error?: string;
}
export type PiWebShortcutConfig = Record<string, string | null>;
export type PiWebPluginSettings = Record<string, unknown>;
export type PiWebPluginConfigMap = Record<string, PiWebPluginConfig>;
export interface PiWebPluginConfig {
    enabled?: boolean;
    settings?: PiWebPluginSettings;
    [key: string]: unknown;
}
export interface PiWebPathAccessConfig {
    allowedPaths?: string[];
}
export interface PiWebUploadsConfig {
    defaultFolder?: string;
}
export interface PiWebAgentConfig {
    /** Pi-compatible companion CLI used for diagnostics and safe package-managed updates. */
    command?: string;
    /** Pi-compatible profile directory containing auth.json, models.json, settings.json, and sessions/. */
    dir?: string;
}
export interface PiWebAgentRuntimesConfig {
    /** Runtime used when session creation does not explicitly choose one. */
    default?: AgentRuntimeId;
    /** External OMP RPC runtime command and isolated profile directory. */
    omp?: PiWebAgentConfig;
}
export interface PiWebConfigValues {
    host?: string;
    port?: number;
    allowedHosts?: string[] | true;
    shortcuts?: PiWebShortcutConfig;
    plugins?: PiWebPluginConfigMap;
    /** External filesystem roots PI WEB may expose outside a workspace. */
    pathAccess?: PiWebPathAccessConfig;
    /** Workspace-relative defaults for manual file uploads. */
    uploads?: PiWebUploadsConfig;
    /** Maximum accepted HTTP request body size in bytes (uploads/attachments). */
    maxUploadBytes?: number;
    /** When true, LLMs can start new sessions via the spawn_session tool. */
    spawnSessions?: boolean;
    /**
     * Beta: when true, LLMs can start tracked child sessions via the
     * spawn_subsession / list_subsessions / check_subsession / read_subsession
     * tools. Off by default
     * while the capability stabilizes. Requires spawnSessions to be enabled.
     */
    subsessions?: boolean;
    /** Desired Pi-compatible embedded agent profile and companion CLI (Pi by default). */
    agent?: PiWebAgentConfig;
    /** Agent runtime control-plane configuration. */
    agentRuntimes?: PiWebAgentRuntimesConfig;
}
export type PiWebPluginScope = "bundled" | "local" | "user" | "project";
export interface PiWebPluginInfo {
    id: string;
    module: string;
    source: string;
    scope: PiWebPluginScope;
    machineSpecific: boolean;
    enabled: boolean;
}
export interface PiWebPluginsResponse {
    plugins: PiWebPluginInfo[];
}
export type PiPackageScope = "user" | "project";
export interface PiPackageInfo {
    source: string;
    scope: PiPackageScope;
    filtered: boolean;
    installedPath?: string;
}
export interface PiPackagesResponse {
    packages: PiPackageInfo[];
}
export interface PiPackageInstallRequest {
    source: string;
}
export interface PiPackageRemoveRequest {
    source: string;
    /** Optional known scope from a listed package; not an install-location picker. */
    scope?: PiPackageScope;
}
export interface PiPackageUpdateRequest {
    /** Omit to update all configured Pi packages. */
    source?: string;
}
export type PiPackageMutationAction = "install" | "remove" | "update";
export interface PiPackageMutationResponse extends PiPackagesResponse {
    action: PiPackageMutationAction;
    source?: string;
    scope?: PiPackageScope;
    removed?: boolean;
}
export type PiWebAgentDirEnvSource = "pi-web" | "pi-compatibility";
export interface PiWebConfigEnvOverrides {
    host: boolean;
    port: boolean;
    allowedHosts: boolean;
    spawnSessions: boolean;
    subsessions: boolean;
    agentCommand: boolean;
    agentDir: boolean;
    /** The configured directory environment source, even when Pi compatibility is inactive for the desired command. */
    agentDirSource?: PiWebAgentDirEnvSource;
    agentSessionDir: boolean;
    /** PI_WEB_OMP_COMMAND pins the OMP runtime command. Absent in responses from older servers. */
    ompCommand?: boolean;
    /** PI_WEB_OMP_AGENT_DIR pins the OMP profile directory. Absent in responses from older servers. */
    ompAgentDir?: boolean;
    /** PI_WEB_DEFAULT_RUNTIME pins the default agent runtime. Absent in responses from older servers. */
    defaultRuntime?: boolean;
}
export interface PiWebConfigResponse {
    path: string;
    exists: boolean;
    config: PiWebConfigValues;
    effectiveConfig: PiWebConfigValues;
    envOverrides: PiWebConfigEnvOverrides;
}
export declare const OMP_SETTING_TYPES: readonly ["boolean", "number", "string", "enum", "array", "record"];
export type OmpSettingType = (typeof OMP_SETTING_TYPES)[number];
export declare function isOmpSettingType(value: unknown): value is OmpSettingType;
/** One editable OMP setting, sourced from `omp config list --json`. */
export interface OmpSettingDescriptor {
    key: string;
    type: OmpSettingType;
    description: string;
    value?: unknown;
    default?: unknown;
    /** Allowed values for enum settings when the installed schema exposes them. */
    enumValues?: string[];
    /** Settings-schema UI grouping, used to organize the settings panel. */
    tab?: string;
    group?: string;
}
/** Payload of GET/PUT /api/machines/local/omp/config. */
export interface OmpConfigResponse {
    available: boolean;
    command?: string;
    configPath?: string;
    error?: string;
    settings: OmpSettingDescriptor[];
}
export interface Project {
    id: string;
    name: string;
    path: string;
    createdAt: string;
}
export interface WorkspaceEffectiveConfig {
    uploads?: PiWebUploadsConfig;
}
export interface Workspace {
    id: string;
    projectId: string;
    path: string;
    label: string;
    branch?: string;
    isMain: boolean;
    isGitRepo: boolean;
    isGitWorktree: boolean;
    /** Workspace-effective project/global settings needed by workspace UI features. */
    effectiveConfig?: WorkspaceEffectiveConfig;
}
export interface SessionRef {
    id: string;
    cwd: string;
    /** Immutable runtime ownership when known; omitted only for rolling-compatibility callers. */
    runtimeId?: AgentRuntimeId;
}
export interface StartSessionRequest {
    cwd: string;
    /** Omitted only by rolling-compatibility clients; the daemon chooses its configured default. */
    runtimeId?: AgentRuntimeId;
}
export declare const SESSION_UNREAD_LIMIT = 1000;
export declare const SESSION_UNREAD_SESSION_ID_MAX_LENGTH = 512;
export declare const SESSION_UNREAD_CWD_MAX_LENGTH: number;
export declare const SESSION_UNREAD_CATALOG_ID_MAX_LENGTH = 512;
export declare const SESSION_UNREAD_COMPLETED_AT_MAX_LENGTH = 64;
export interface SessionUnreadSummary {
    sessionId: string;
    cwd: string;
    /** Monotonic within a catalog and never greater than its containing revision. */
    completionOrder: number;
    completedAt: string;
}
export interface SessionUnreadCatalogSnapshot {
    /** Stable for one persisted catalog epoch; changes when unread state is reset. */
    catalogId: string;
    /** Monotonic catalog mutation revision; at least every contained completion order. */
    catalogRevision: number;
    /** Bounded by `SESSION_UNREAD_LIMIT` and ordered newest completion first. */
    sessions: SessionUnreadSummary[];
}
export interface SessionUnreadAcknowledgeRequest {
    cwd: string;
    /** The catalog epoch in which `throughCompletionOrder` was observed. */
    catalogId: string;
    throughCompletionOrder: number;
}
/** Authoritative delta for one session in the daemon-owned unread catalog. */
export interface SessionUnreadEvent {
    type: "sessions.unread";
    catalogId: string;
    /** At least `unread.completionOrder` when carrying an unread summary. */
    catalogRevision: number;
    sessionId: string;
    cwd: string;
    unread: SessionUnreadSummary | null;
}
export declare const SESSION_NOTIFICATION_LIMIT = 100;
export declare const SESSION_NOTIFICATION_MESSAGE_BYTES: number;
export type SessionNotificationSeverity = "info" | "warning" | "error";
export interface SessionNotification {
    id: string;
    message: string;
    truncated: boolean;
    severity: SessionNotificationSeverity;
    receivedAt: string;
    order: number;
}
export interface SessionNotificationSummary {
    sessionId: string;
    cwd: string;
    inboxRevision: number;
    retainedCount: number;
    discardedCount: number;
    highestSeverity?: SessionNotificationSeverity;
}
export interface SessionNotificationDismissThrough {
    order: number;
    overflowWatermark: number;
}
export interface SessionNotificationInboxSnapshot {
    daemonInstanceId: string;
    catalogRevision: number;
    summary: SessionNotificationSummary;
    notifications: SessionNotification[];
    dismissThrough: SessionNotificationDismissThrough;
}
export interface SessionNotificationCatalogSnapshot {
    daemonInstanceId: string;
    catalogRevision: number;
    sessions: SessionNotificationSummary[];
}
export interface SessionNotificationDismissRequest {
    cwd: string;
    daemonInstanceId: string;
    notificationId: string;
}
export interface SessionNotificationDismissAllRequest {
    cwd: string;
    daemonInstanceId: string;
    throughOrder: number;
    throughOverflowWatermark: number;
}
export type SessionNotificationClearReason = "runtime-close" | "archive" | "delete" | "restore" | "archive-reconcile" | "replacement" | "initialization-failed" | "service-dispose";
export type SessionNotificationInboxDelta = {
    kind: "added";
    notification: SessionNotification;
    evictedNotificationId?: string;
} | {
    kind: "dismissed";
    notificationIds: string[];
} | {
    kind: "cleared";
    reason: SessionNotificationClearReason;
} | {
    kind: "resync";
};
export interface SessionNotificationInboxEvent {
    type: "notifications.inbox";
    daemonInstanceId: string;
    catalogRevision: number;
    summary: SessionNotificationSummary;
    dismissThrough: SessionNotificationDismissThrough;
    delta: SessionNotificationInboxDelta;
}
export interface SessionNotificationSummaryEvent {
    type: "notifications.summary";
    daemonInstanceId: string;
    catalogRevision: number;
    summary: SessionNotificationSummary;
}
export interface SessionInfo extends SessionRef {
    /** Authoritative immutable runtime ownership returned by current daemons. */
    runtimeId: AgentRuntimeId;
    path: string;
    /** True when the server has verified a backing session file exists; false when known transient. */
    persisted?: boolean;
    name?: string;
    created: string;
    modified: string;
    messageCount: number;
    firstMessage: string;
    parentSessionPath?: string;
    archived?: boolean;
    archivedAt?: string;
}
export interface ArchiveSessionsResponse {
    archived: true;
    sessionIds?: string[];
    archivedCount?: number;
    skippedAlreadyArchivedCount?: number;
}
export interface SessionBulkMutationRef {
    id: string;
    cwd?: string;
    runtimeId?: AgentRuntimeId;
}
export interface SessionBulkMutationRequest {
    sessions: SessionBulkMutationRef[];
}
export interface SessionBulkFailure {
    sessionId: string;
    error: string;
}
export interface SessionBulkArchiveResponse {
    archived: true;
    archivedSessionIds: string[];
    failures: SessionBulkFailure[];
    generatedAt: string;
}
export interface SessionBulkDeleteArchivedResponse {
    deleted: true;
    deletedSessionIds: string[];
    failures: SessionBulkFailure[];
    generatedAt: string;
}
export interface SessionCleanupRequest {
    /** Archive non-archived sessions whose modified time is older than this many days. Omit/null to disable. */
    archiveIdleDays?: number | null;
    /** Permanently delete archived sessions whose archivedAt time is older than this many days. Omit/null to disable. */
    deleteArchivedDays?: number | null;
    /** Stored cwd paths selected from a preview. Omit/null to include all discovered project/workspace paths. */
    projectCwds?: string[] | null;
}
export interface SessionCleanupThresholds {
    archiveIdleDays?: number;
    deleteArchivedDays?: number;
}
export interface SessionCleanupProjectSummary {
    cwd: string;
    archiveCount: number;
    deleteCount: number;
}
export interface SessionCleanupTotals {
    archiveCount: number;
    deleteCount: number;
}
export interface SessionCleanupPreviewResponse {
    generatedAt: string;
    thresholds: SessionCleanupThresholds;
    projects: SessionCleanupProjectSummary[];
    totals: SessionCleanupTotals;
    skippedBusySessionIds?: string[];
}
export interface SessionCleanupExecuteResponse extends SessionCleanupPreviewResponse {
    archivedSessionIds: string[];
    deletedSessionIds: string[];
}
export interface SessionActivity {
    sessionId: string;
    phase: "active" | "idle" | "error";
    label: string;
    detail?: string;
    at: string;
}
export interface QueuedSessionMessage {
    kind: "steer" | "followUp";
    text: string;
}
/**
 * A pi-native image attachment carried with a prompt. The wire format mirrors
 * pi's own `ImageContent` shape (`{ type: "image", data, mimeType }`) so these
 * attachments are compatible with native multimodal delivery after validation.
 */
export interface PromptImageAttachment {
    kind: "image";
    /** Supported image MIME type (image/png, image/jpeg, image/gif, or image/webp). */
    mimeType: string;
    /** Base64-encoded binary payload (no data: URL prefix). */
    data: string;
    /** Optional original filename, used for previews and folder-mode filenames. */
    name?: string;
}
/** A general file attachment that must be saved into the workspace before use. */
export interface PromptFileAttachment {
    kind: "file";
    /** Non-empty IANA MIME type (for example "application/pdf"). */
    mimeType: string;
    /** Base64-encoded binary payload (no data: URL prefix). Empty for zero-byte files. */
    data: string;
    /** Optional original filename, used for previews and folder-mode filenames. */
    name?: string;
}
export type PromptAttachment = PromptImageAttachment | PromptFileAttachment;
/**
 * How prompt attachments should be delivered to the session.
 * - "inline": send the binary to pi as native image content (multimodal input).
 * - "folder": save the file into the workspace and reference it from the prompt
 *   text so the agent reads it with its own tools.
 */
export type PromptAttachmentDelivery = "inline" | "folder";
export interface SavedPromptAttachment {
    /** Workspace-relative path the attachment was written to. */
    path: string;
    mimeType: string;
    size: number;
}
export interface SessionModel {
    provider?: string;
    id?: string;
    name?: string;
    contextWindow?: number;
    reasoning?: unknown;
}
export type { ThinkingLevel } from "./thinkingLevels.js";
export type AuthType = "oauth" | "api_key";
export type AuthStatusSource = "stored" | "runtime" | "environment" | "fallback" | "models_json_key" | "models_json_command";
export interface AuthProviderStatus {
    configured: boolean;
    source?: AuthStatusSource;
    label?: string;
}
export interface AuthProviderOption {
    id: string;
    name: string;
    authType: AuthType;
    status: AuthProviderStatus;
    /** Additive hint: use the generic AuthInteraction transport instead of the legacy one-secret form. */
    loginFlow?: "interactive";
}
export interface AuthProvidersResponse {
    providers: AuthProviderOption[];
}
export interface OAuthFlowState {
    flowId: string;
    providerId: string;
    providerName: string;
    status: "running" | "complete" | "error" | "cancelled";
    auth?: {
        url: string;
        instructions?: string;
        deviceCode?: {
            userCode: string;
            intervalSeconds?: number;
            expiresInSeconds?: number;
        };
    };
    prompt?: {
        requestId: string;
        message: string;
        placeholder?: string;
        allowEmpty?: boolean;
        /** Additive semantic detail; legacy peers continue to use `kind`. */
        promptType?: "text" | "secret" | "manual_code";
        kind: "prompt" | "manual";
    };
    select?: {
        requestId: string;
        message: string;
        options: CommandOption[];
    };
    progress: string[];
    info?: {
        message: string;
        links?: {
            url: string;
            label?: string;
        }[];
    }[];
    error?: string;
}
export interface ModelSelectionResponse {
    models: SessionModel[];
}
export interface ThinkingLevelsResponse {
    levels: string[];
}
export type SessionWarningSeverity = "info" | "warning" | "error";
/**
 * A live, runtime-scoped warning surfaced to the browser (skill/resource
 * diagnostics, extension load errors, subscription-auth billing notice, etc.).
 *
 * Warnings are recomputed whenever the runtime is (re)built inside sessiond and
 * are not persisted chat messages. `source` is an optional short origin label
 * (e.g. `"skill"`, `"extension"`, `"anthropic"`); `path` carries a related file
 * path when the warning came from a resource diagnostic.
 *
 * `dismiss` is present only when the warning has a durable, first-class
 * off-switch in the underlying `pi` agent (not a UI-only hide). Its `id` is the
 * opaque token the server maps back to that suppression; the client renders a
 * dismiss control for any warning carrying it, without knowing what it means.
 */
export interface SessionWarning {
    severity: SessionWarningSeverity;
    message: string;
    source?: string;
    path?: string;
    dismiss?: {
        id: string;
    };
}
export interface SessionStatus {
    sessionId: string;
    /** Immutable runtime ownership; current daemons always return it, legacy peers may omit it. */
    runtimeId?: AgentRuntimeId;
    /** True when the server has verified a backing session file exists; false when known transient. */
    persisted?: boolean;
    model?: SessionModel;
    thinkingLevel?: string;
    isStreaming: boolean;
    isCompacting: boolean;
    isBashRunning: boolean;
    pendingMessageCount: number;
    queuedMessages: QueuedSessionMessage[];
    messageCount?: number;
    tokens: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
        total: number;
    };
    cost: number;
    contextUsage?: {
        tokens: number | null;
        contextWindow: number;
        percent: number | null;
    };
    /**
     * Live, runtime-scoped warnings for this session (skill/resource diagnostics,
     * extension load errors, Anthropic subscription-auth billing notice, etc.).
     * Recomputed on each status read from the current runtime; absent/empty when
     * there are none. See {@link SessionWarning}.
     */
    warnings?: SessionWarning[];
}
export interface WorkspaceActivity {
    cwd: string;
    hasSessionActivity: boolean;
    hasTerminalActivity: boolean;
    updatedAt: string;
}
export interface WorkspaceActivityResponse {
    workspaces: WorkspaceActivity[];
    generatedAt: string;
}
export interface SlashCommand {
    name: string;
    description?: string;
    source: "extension" | "prompt" | "skill" | "builtin";
}
export interface FileSuggestion {
    path: string;
    kind: "tracked" | "untracked" | "other";
}
export interface FileTreeEntry {
    name: string;
    path: string;
    type: "file" | "directory" | "symlink";
    size?: number;
    modifiedAt?: string;
}
export interface FileTreeResponse {
    path: string;
    entries: FileTreeEntry[];
    scannedAt: string;
    truncated: boolean;
}
export type FileContentMediaType = "image";
export interface FileContentResponse {
    path: string;
    language?: string;
    mediaType?: FileContentMediaType;
    mimeType?: string;
    encoding: "utf8";
    size: number;
    modifiedAt: string;
    content: string;
    truncated: boolean;
    binary: boolean;
}
/**
 * A bounded, Runtime-owned image payload for a native client preview.
 * `data` is standard base64 with no data-URL prefix, so a client cannot turn
 * an arbitrary workspace path into a direct local-file URL.
 */
export interface WorkspaceImagePreviewResponse {
    path: string;
    mimeType: string;
    size: number;
    modifiedAt: string;
    data: string;
}
export interface WriteWorkspaceFileOptions {
    createDirs?: boolean;
    overwrite?: boolean;
}
export interface WriteWorkspaceFileResponse {
    path: string;
    size: number;
    modifiedAt: string;
    created: boolean;
}
export interface DeleteWorkspaceFileResponse {
    path: string;
    existed: boolean;
}
export interface MoveWorkspaceFileOptions {
    createDirs?: boolean;
    overwrite?: boolean;
}
export interface MoveWorkspaceFileResponse {
    fromPath: string;
    toPath: string;
    size: number;
    modifiedAt: string;
}
export type GitFileState = "unmodified" | "modified" | "added" | "deleted" | "renamed" | "copied" | "untracked" | "ignored" | "conflicted";
export interface GitStatusFile {
    path: string;
    oldPath?: string;
    index: GitFileState;
    workingTree: GitFileState;
    submoduleFromCommit?: string;
    submoduleToCommit?: string;
}
export interface GitStatusResponse {
    isGitRepo: boolean;
    hash: string;
    branch?: string;
    upstream?: string;
    ahead?: number;
    behind?: number;
    files: GitStatusFile[];
    submodules: string[];
}
export interface GitDiffResponse {
    path?: string;
    staged: boolean;
    hash: string;
    diff: string;
    truncated: boolean;
}
/**
 * A fresh, Runtime-owned decision about whether the current branch can be
 * safely pushed to its existing tracking upstream. The App never supplies a
 * remote, branch, refspec, or force option.
 */
export interface GitPushPreview {
    status: GitStatusResponse;
    canPush: boolean;
    reason?: string;
}
/** Read-only policy for undoing HEAD without rewriting history. */
export interface GitRevertPreview {
    status: GitStatusResponse;
    canRevert: boolean;
    reason?: string;
    commit?: {
        hash: string;
        subject: string;
    };
}
/** A bounded, local snapshot for native Thread review. It is not a Git ref. */
export interface GitCheckpointDiff {
    hash: string;
    diff: string;
    truncated: boolean;
}
export interface GitCheckpoint {
    id: string;
    sessionId: string;
    cwd: string;
    createdAt: string;
    status: GitStatusResponse;
    unstaged: GitCheckpointDiff;
    staged: GitCheckpointDiff;
}
export interface GitCheckpointFile {
    checkpoints: GitCheckpoint[];
}
export interface TerminalInfo {
    id: string;
    cwd: string;
    name: string;
    createdAt: string;
    exited: boolean;
    exitCode?: number;
    commandRunId?: string;
}
export type TerminalCommandRunStatus = "queued" | "running" | "succeeded" | "failed";
export interface TerminalCommandRun {
    id: string;
    origin: string;
    projectId: string;
    workspaceId: string;
    terminalId: string;
    title: string;
    command: string;
    status: TerminalCommandRunStatus;
    exitCode?: number;
    createdAt: string;
    startedAt?: string;
    completedAt?: string;
    metadata: Record<string, string>;
}
export interface RunTerminalCommandInput {
    workspace: Workspace;
    title: string;
    command: string;
    metadata?: Record<string, string>;
    open?: boolean;
}
export interface TerminalCommandRunHandle {
    run: TerminalCommandRun;
    completed: Promise<TerminalCommandRun>;
}
export interface TerminalCommandRunFilter {
    projectId?: string;
    workspaceId?: string;
    terminalId?: string;
    statuses?: TerminalCommandRunStatus[];
    metadata?: Record<string, string>;
}
export type PiWebServiceComponent = "web" | "sessiond";
export type PiWebStatusSeverity = "info" | "warning" | "error";
export type PiWebInstallationKind = "pi-package" | "npm-global" | "local" | "docker" | "unknown";
export type PiWebDockerMode = "runtime" | "dev";
export interface PiWebInstallationInfo {
    kind: PiWebInstallationKind;
    path?: string;
    source?: string;
    scope?: "user" | "project";
    npmRoot?: string;
    dockerMode?: PiWebDockerMode;
}
export interface PiWebComponentStatus {
    component: PiWebServiceComponent;
    label: string;
    runtimeVersion?: string;
    installedVersion?: string;
    stale: boolean;
    available: boolean;
    installation?: PiWebInstallationInfo;
    error?: string;
}
/** Secret-free identity of the Pi-compatible CLI/state profile fixed for one sessiond lifetime. */
export interface ActiveAgentProfileDescriptor {
    readonly schemaVersion: 1;
    readonly revision: string;
    readonly command: string;
    readonly dir: string;
    readonly sessionDirEnvKeys: readonly string[];
}
export interface PiWebRuntimeComponent {
    component: PiWebServiceComponent;
    label: string;
    runtimeVersion?: string;
    available: boolean;
    capabilities: PiWebCapability[];
    /** Present only for a session daemon that supports active-profile reporting. */
    activeAgentProfile?: ActiveAgentProfileDescriptor;
    error?: string;
}
export interface PiWebReleaseStatus {
    packageName: string;
    latestVersion?: string;
    updateAvailable: boolean;
    checkedAt?: string;
    skipped?: boolean;
    error?: string;
}
export interface PiWebStatusMessage {
    id: string;
    severity: PiWebStatusSeverity;
    title: string;
    body: string;
    command?: string;
}
export interface PiWebVersionResponse {
    packageName: string;
    generatedAt: string;
    components: {
        web: PiWebComponentStatus;
        sessiond: PiWebComponentStatus;
    };
}
export interface PiWebRuntimeResponse {
    packageName: string;
    generatedAt: string;
    components: {
        web: PiWebRuntimeComponent;
        sessiond: PiWebRuntimeComponent;
    };
    capabilities: PiWebCapability[];
}
export interface PiWebStatusResponse extends PiWebVersionResponse {
    release: PiWebReleaseStatus;
    commands: {
        update?: string;
        restart?: string;
        restartWeb?: string;
        restartSessiond?: string;
        status?: string;
    };
    messages: PiWebStatusMessage[];
}
export type TerminalUiEvent = {
    type: "terminal.created";
    terminal: TerminalInfo;
} | {
    type: "terminal.exited";
    terminal: TerminalInfo;
} | {
    type: "terminal.closed";
    terminalId: string;
    cwd: string;
};
export interface WorkspaceActivityUiEvent {
    type: "workspace.activity";
    activity: WorkspaceActivity;
}
export interface CommandOption {
    value: string;
    label: string;
    description?: string;
}
export type SessionTreeNodeKind = "user" | "assistant" | "tool-result" | "bash" | "custom-message" | "compaction" | "branch-summary" | "model-change" | "thinking-level-change" | "session-info" | "label" | "custom" | "other";
export interface SessionTreeNode {
    id: string;
    parentId: string | null;
    kind: SessionTreeNodeKind;
    summary: string;
    timestamp?: string;
    label?: string;
}
export interface SessionTreeSnapshot {
    /** Pre-order, parent-linked projection of all retained roots and descendants. */
    nodes: SessionTreeNode[];
    activeLeafId: string | null;
    /** Root-to-leaf IDs for explicit, non-color-only active-path rendering. */
    activePathIds: string[];
}
export declare const SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH = 10000;
export type SessionTreeSummaryChoice = {
    mode: "none";
} | {
    mode: "default";
} | {
    mode: "custom";
    instructions: string;
};
export interface SessionTreeNavigateRequest {
    targetId: string;
    /** Leaf shown when the navigator opened; null is valid for an empty/root position. */
    expectedLeafId: string | null;
    summary: SessionTreeSummaryChoice;
}
export type SessionTreeNavigateResult = {
    cancelled: false;
    editorText?: string;
} | {
    cancelled: true;
    aborted?: boolean;
};
export interface MessagePage {
    messages: unknown[];
    start: number;
    total: number;
}
/**
 * Join-time snapshot of a session's in-flight assistant stream. `seq` is the
 * `SessionEventHub` watermark captured together with `partial` in a single tick,
 * so a joining client can seed `partial` and then apply only buffered live events
 * with `seq > snapshot.seq` (exactly-once). `partial` is a browser-projected
 * in-flight `AssistantMessage` (thinking signatures stripped), or `null` when the
 * session is not mid assistant-message stream.
 */
export interface SessionStreamSnapshot {
    seq: number;
    /** Browser-projected in-flight `AssistantMessage`, or `null` when idle. */
    partial: unknown;
}
export type CommandResult = {
    type: "done";
    message?: string;
    session?: SessionInfo;
    promptDraft?: string;
} | {
    type: "select";
    requestId: string;
    title: string;
    options: CommandOption[];
} | {
    type: "tree";
    tree: SessionTreeSnapshot;
} | {
    type: "unsupported";
    message: string;
};
/**
 * Transport-level per-session sequence stamp. `SessionEventHub.publish` assigns a
 * monotonic `seq` to every per-session event as it is serialized to the socket.
 * Clients use it as a watermark against the join-time stream snapshot so buffered
 * live events are applied exactly once. Existing consumers may ignore it.
 */
export type SessionUiEvent = SessionUiEventBody & {
    seq?: number;
};
type SessionUiEventBody = {
    type: "message.append";
    message: unknown;
} | {
    type: "assistant.delta";
    text: string;
} | {
    type: "assistant.thinking.delta";
    text: string;
} | {
    type: "tool.start";
    toolName: string;
    toolCallId: string;
    summary: string;
    args?: unknown;
} | {
    type: "tool.update";
    toolName: string;
    toolCallId: string;
    text: string;
    content?: unknown;
    details?: unknown;
} | {
    type: "tool.end";
    toolName: string;
    toolCallId: string;
    text: string;
    isError: boolean;
    content?: unknown;
    details?: unknown;
} | {
    type: "shell.start";
    command: string;
    excludeFromContext?: boolean;
} | {
    type: "shell.chunk";
    chunk: string;
} | {
    type: "shell.end";
    output?: string;
    exitCode?: number | null;
    cancelled?: boolean;
    truncated?: boolean;
    fullOutputPath?: string;
    isError?: boolean;
} | {
    type: "agent.start";
} | {
    type: "agent.end";
} | {
    type: "message.end";
    message?: unknown;
} | {
    type: "status.update";
    status: SessionStatus;
} | {
    type: "activity.update";
    activity: SessionActivity;
} | {
    type: "command.output";
    level: "info" | "success" | "error";
    message: string;
    notificationId?: string;
} | SessionNotificationInboxEvent | {
    type: "session.error";
    message: string;
} | {
    type: "extension.interaction.opened" | "extension.interaction.closed";
    interactionId: string;
    interactionKind: "select" | "confirm" | "input" | "editor";
    reason?: string;
} | {
    type: "session.name";
    sessionId: string;
    name?: string;
} | {
    type: "session.created";
    session: SessionInfo;
} | {
    type: "runtime.event";
    runtimeId: AgentRuntimeId;
    eventType: string;
    event?: unknown;
} | {
    type: "pi.event";
    eventType: string;
};
export type GlobalSessionEvent = Extract<SessionUiEventBody, {
    type: "status.update" | "activity.update" | "session.name" | "session.created";
}> | SessionNotificationSummaryEvent | SessionUnreadEvent;
export type RealtimeEvent = GlobalSessionEvent | TerminalUiEvent | WorkspaceActivityUiEvent;