@bubblebrain-ai/bubble 0.0.1

package/dist/context/overflow.js

@@ -0,0 +1,46 @@
+/**
+ * Context-overflow detection.
+ *
+ * When the upstream provider rejects a request because the prompt exceeds
+ * the effective context window, we catch the error here so the agent can
+ * compact history and retry automatically.
+ */
+const OVERFLOW_PATTERNS = [
+    /context[_ ]length[_ ]exceeded/i,
+    /exceeds the context window/i,
+    /exceeds the limit of\s+\d+/i,
+    /prompt is too long/i,
+    /maximum context length/i,
+    /too many tokens/i,
+];
+export function isContextOverflowError(error) {
+    if (!error)
+        return false;
+    const messages = [];
+    if (typeof error === "string") {
+        messages.push(error);
+    }
+    else if (error instanceof Error) {
+        messages.push(error.message);
+        const cause = error.cause;
+        if (cause instanceof Error)
+            messages.push(cause.message);
+        else if (typeof cause === "string")
+            messages.push(cause);
+    }
+    else if (typeof error === "object") {
+        const anyErr = error;
+        if (typeof anyErr.message === "string")
+            messages.push(anyErr.message);
+        const nested = anyErr.error;
+        if (nested && typeof nested === "object" && typeof nested.message === "string") {
+            messages.push(nested.message);
+        }
+    }
+    return messages.some((msg) => OVERFLOW_PATTERNS.some((re) => re.test(msg)));
+}
+export function isContextOverflowByUsage(inputTokens, contextWindow) {
+    if (!inputTokens || !contextWindow)
+        return false;
+    return inputTokens > contextWindow;
+}

package/dist/context/projector.d.ts

@@ -0,0 +1,26 @@
+import type { Message } from "../types.js";
+export interface ProjectionOptions {
+    mode?: "full" | "pruned" | "budgeted";
+    providerId?: string;
+    modelId?: string;
+    usageAnchorTokens?: number;
+    anchorMessageCount?: number;
+}
+export declare function projectMessages(messages: Message[], options?: ProjectionOptions): Message[];
+/**
+ * Ensures every assistant `tool_calls` is followed (in order) by tool messages
+ * responding to each tool_call_id, with no foreign messages interleaved.
+ *
+ * This is a defensive sanitizer for the OpenAI/Kimi API contract — any drift
+ * (a meta system-reminder injected mid-turn, a streaming bug, a session
+ * resumed mid-tool-execution, a compaction split that drops a tool result)
+ * would otherwise produce a 400 like:
+ *
+ *   "tool_call_ids did not have response messages: edit:6"
+ *
+ * Strategy: for each assistant with tool_calls, gather any matching tool
+ * messages from the trailing window, drop orphan/interleaving entries, and
+ * synthesize placeholder tool messages for any tool_call_id with no captured
+ * result. Other messages keep their original order.
+ */
+export declare function repairToolCallChains(messages: Message[]): Message[];

package/dist/context/projector.js

@@ -0,0 +1,150 @@
+import { getContextBudget } from "./budget.js";
+import { compactMessages } from "./compact.js";
+import { pruneMessages } from "./prune.js";
+export function projectMessages(messages, options = {}) {
+    const mode = options.mode ?? "full";
+    const projected = [];
+    let systemBuffer = [];
+    const flushSystemBuffer = () => {
+        if (systemBuffer.length === 0)
+            return;
+        projected.push({
+            role: "system",
+            content: systemBuffer.join("\n\n"),
+        });
+        systemBuffer = [];
+    };
+    for (const message of messages) {
+        if (message.role === "system") {
+            systemBuffer.push(message.content);
+            continue;
+        }
+        flushSystemBuffer();
+        if (message.role === "assistant" && isEmptyAssistantMessage(message)) {
+            continue;
+        }
+        projected.push(cloneMessage(message));
+    }
+    flushSystemBuffer();
+    const repaired = repairToolCallChains(projected);
+    if (mode === "pruned") {
+        return pruneMessages(repaired);
+    }
+    if (mode === "budgeted") {
+        const pruned = pruneMessages(repaired);
+        if (!options.providerId || !options.modelId) {
+            return pruned;
+        }
+        const budget = getContextBudget(options.providerId, options.modelId, pruned, options.usageAnchorTokens !== undefined && options.anchorMessageCount !== undefined
+            ? {
+                usageAnchorTokens: options.usageAnchorTokens,
+                tailMessages: pruned.slice(Math.min(options.anchorMessageCount, pruned.length)),
+            }
+            : undefined);
+        if (!budget.shouldCompact) {
+            return pruned;
+        }
+        const compacted = compactMessages(pruned, { keepRecentTurns: 2 });
+        if (!compacted.compacted || !compacted.messages) {
+            return pruned;
+        }
+        const afterFirstPass = getContextBudget(options.providerId, options.modelId, compacted.messages);
+        if (!afterFirstPass.shouldCompact) {
+            return repairToolCallChains(compacted.messages);
+        }
+        const tighter = compactMessages(pruned, { keepRecentTurns: 1 });
+        const finalMessages = tighter.compacted && tighter.messages ? tighter.messages : compacted.messages;
+        return repairToolCallChains(finalMessages);
+    }
+    return repaired;
+}
+/**
+ * Ensures every assistant `tool_calls` is followed (in order) by tool messages
+ * responding to each tool_call_id, with no foreign messages interleaved.
+ *
+ * This is a defensive sanitizer for the OpenAI/Kimi API contract — any drift
+ * (a meta system-reminder injected mid-turn, a streaming bug, a session
+ * resumed mid-tool-execution, a compaction split that drops a tool result)
+ * would otherwise produce a 400 like:
+ *
+ *   "tool_call_ids did not have response messages: edit:6"
+ *
+ * Strategy: for each assistant with tool_calls, gather any matching tool
+ * messages from the trailing window, drop orphan/interleaving entries, and
+ * synthesize placeholder tool messages for any tool_call_id with no captured
+ * result. Other messages keep their original order.
+ */
+export function repairToolCallChains(messages) {
+    const result = [];
+    const consumed = new Set();
+    for (let i = 0; i < messages.length; i++) {
+        if (consumed.has(i))
+            continue;
+        const msg = messages[i];
+        if (msg.role === "tool") {
+            // Orphan tool message (no preceding assistant tool_call claims it). Drop it —
+            // the API rejects orphan tool messages too.
+            continue;
+        }
+        result.push(msg);
+        if (msg.role !== "assistant" || !msg.toolCalls || msg.toolCalls.length === 0) {
+            continue;
+        }
+        // Collect tool messages immediately following the assistant turn (allowing
+        // foreign messages in between to be skipped, then re-emitted in their
+        // original positions later).
+        const matched = new Map();
+        const expected = new Set(msg.toolCalls.map((tc) => tc.id));
+        for (let j = i + 1; j < messages.length && expected.size > 0; j++) {
+            const next = messages[j];
+            if (next.role !== "tool")
+                continue;
+            if (!expected.has(next.toolCallId)) {
+                // Orphan tool message — mark consumed so we don't emit it later.
+                consumed.add(j);
+                continue;
+            }
+            matched.set(next.toolCallId, next);
+            expected.delete(next.toolCallId);
+            consumed.add(j);
+        }
+        for (const tc of msg.toolCalls) {
+            const existing = matched.get(tc.id);
+            if (existing) {
+                result.push(existing);
+            }
+            else {
+                result.push({
+                    role: "tool",
+                    toolCallId: tc.id,
+                    content: `[no result captured for tool call ${tc.name} (${tc.id})]`,
+                });
+            }
+        }
+    }
+    return result;
+}
+function isEmptyAssistantMessage(message) {
+    const hasContent = message.content.trim().length > 0;
+    const hasReasoning = (message.reasoning ?? "").trim().length > 0;
+    const hasToolCalls = !!message.toolCalls && message.toolCalls.length > 0;
+    return !hasContent && !hasReasoning && !hasToolCalls;
+}
+function cloneMessage(message) {
+    if (message.role === "assistant") {
+        return {
+            ...message,
+            toolCalls: message.toolCalls?.map((toolCall) => ({ ...toolCall })),
+        };
+    }
+    if (message.role === "user" && Array.isArray(message.content)) {
+        return {
+            ...message,
+            content: message.content.map((part) => ({
+                ...part,
+                ...(part.type === "image_url" ? { image_url: { ...part.image_url } } : {}),
+            })),
+        };
+    }
+    return { ...message };
+}

package/dist/context/prune.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../types.js";
+export declare function pruneMessages(messages: Message[]): Message[];
+/**
+ * Aggressive variant of pruneMessages: drops the content of every prunable
+ * tool output except the latest unresolved tool turn that the model still
+ * needs to reason over. Used as a last-resort microcompact pass when a
+ * standard prune hasn't reclaimed enough budget.
+ */
+export declare function aggressivePruneMessages(messages: Message[]): Message[];

package/dist/context/prune.js

@@ -0,0 +1,111 @@
+const PRUNEABLE_TOOLS = new Set([
+    "read", "bash", "grep", "web_search", "web_fetch", "edit", "write", "glob",
+]);
+const TOOL_RESULT_KEEP_COUNT = 2;
+const MIN_PRUNE_LENGTH = 240;
+export function pruneMessages(messages) {
+    const toolNameByCallId = new Map();
+    const pruneCandidates = [];
+    const protectedToolCallIds = collectProtectedToolCallIds(messages);
+    let protectedRetainedCount = 0;
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role === "assistant" && message.toolCalls) {
+            for (const toolCall of message.toolCalls) {
+                toolNameByCallId.set(toolCall.id, toolCall.name);
+            }
+            continue;
+        }
+        if (message.role !== "tool") {
+            continue;
+        }
+        if (protectedToolCallIds.has(message.toolCallId)) {
+            const toolName = toolNameByCallId.get(message.toolCallId);
+            if (toolName && shouldPruneToolResult(toolName, message.content)) {
+                protectedRetainedCount += 1;
+            }
+            continue;
+        }
+        const toolName = toolNameByCallId.get(message.toolCallId);
+        if (!toolName || !shouldPruneToolResult(toolName, message.content)) {
+            continue;
+        }
+        pruneCandidates.push({ index, toolName, message });
+    }
+    const keepBudget = Math.max(0, TOOL_RESULT_KEEP_COUNT - protectedRetainedCount);
+    const keepFrom = Math.max(0, pruneCandidates.length - keepBudget);
+    const keepIndexes = new Set(pruneCandidates.slice(keepFrom).map((candidate) => candidate.index));
+    return messages.map((message, index) => {
+        if (message.role !== "tool" || keepIndexes.has(index)) {
+            return message;
+        }
+        const candidate = pruneCandidates.find((item) => item.index === index);
+        if (!candidate) {
+            return message;
+        }
+        return {
+            ...message,
+            content: summarizePrunedToolResult(candidate.toolName, candidate.message.content),
+        };
+    });
+}
+function shouldPruneToolResult(toolName, content) {
+    if (!PRUNEABLE_TOOLS.has(toolName)) {
+        return false;
+    }
+    if (content.length < MIN_PRUNE_LENGTH) {
+        return false;
+    }
+    if (content.startsWith("Error")) {
+        return false;
+    }
+    return true;
+}
+function summarizePrunedToolResult(toolName, content) {
+    return `[${toolName} output omitted to control context size; original length ${content.length} chars]`;
+}
+/**
+ * Aggressive variant of pruneMessages: drops the content of every prunable
+ * tool output except the latest unresolved tool turn that the model still
+ * needs to reason over. Used as a last-resort microcompact pass when a
+ * standard prune hasn't reclaimed enough budget.
+ */
+export function aggressivePruneMessages(messages) {
+    const toolNameByCallId = new Map();
+    const protectedToolCallIds = collectProtectedToolCallIds(messages);
+    for (const message of messages) {
+        if (message.role === "assistant" && message.toolCalls) {
+            for (const toolCall of message.toolCalls) {
+                toolNameByCallId.set(toolCall.id, toolCall.name);
+            }
+        }
+    }
+    return messages.map((message) => {
+        if (message.role !== "tool")
+            return message;
+        if (protectedToolCallIds.has(message.toolCallId)) {
+            return message;
+        }
+        const toolName = toolNameByCallId.get(message.toolCallId);
+        if (!toolName || !shouldPruneToolResult(toolName, message.content)) {
+            return message;
+        }
+        return { ...message, content: summarizePrunedToolResult(toolName, message.content) };
+    });
+}
+function collectProtectedToolCallIds(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role === "tool" || message.role === "system") {
+            continue;
+        }
+        if (message.role === "user" && message.isMeta) {
+            continue;
+        }
+        if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+            return new Set(message.toolCalls.map((toolCall) => toolCall.id));
+        }
+        break;
+    }
+    return new Set();
+}

package/dist/lsp/config.d.ts

@@ -0,0 +1,18 @@
+export interface LspServerConfig {
+    disabled?: boolean;
+    command?: string[];
+    extensions?: string[];
+    rootMarkers?: string[];
+    env?: Record<string, string>;
+    initializationOptions?: Record<string, unknown>;
+    languageId?: string;
+}
+export type BuiltinLspServerId = "typescript" | "deno" | "vue" | "eslint" | "oxlint";
+export type LspServerId = BuiltinLspServerId | string;
+export type LspConfig = boolean | Record<string, LspServerConfig>;
+export declare const BUILTIN_LSP_SERVER_IDS: readonly BuiltinLspServerId[];
+export declare function normalizeLspConfig(value: unknown): LspConfig | undefined;
+export declare function isLspEnabled(config: LspConfig | undefined): boolean;
+export declare function isLspServerEnabled(config: LspConfig | undefined, id: LspServerId): boolean;
+export declare function isTypeScriptLspEnabled(config: LspConfig | undefined): boolean;
+export declare function customLspServerEntries(config: LspConfig | undefined): Array<[string, LspServerConfig]>;

package/dist/lsp/config.js

@@ -0,0 +1,58 @@
+export const BUILTIN_LSP_SERVER_IDS = ["typescript", "deno", "vue", "eslint", "oxlint"];
+export function normalizeLspConfig(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const config = {};
+    for (const [id, value] of Object.entries(raw)) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const server = value;
+        const next = {};
+        if (typeof server.disabled === "boolean")
+            next.disabled = server.disabled;
+        if (isStringArray(server.command) && server.command.length > 0)
+            next.command = server.command;
+        if (isStringArray(server.extensions))
+            next.extensions = server.extensions;
+        if (isStringArray(server.rootMarkers))
+            next.rootMarkers = server.rootMarkers;
+        if (server.env && typeof server.env === "object" && !Array.isArray(server.env)) {
+            next.env = Object.fromEntries(Object.entries(server.env).filter((entry) => typeof entry[1] === "string"));
+        }
+        if (server.initializationOptions && typeof server.initializationOptions === "object" && !Array.isArray(server.initializationOptions)) {
+            next.initializationOptions = server.initializationOptions;
+        }
+        if (typeof server.languageId === "string")
+            next.languageId = server.languageId;
+        config[id] = next;
+    }
+    return config;
+}
+export function isLspEnabled(config) {
+    return config !== false;
+}
+export function isLspServerEnabled(config, id) {
+    if (!isLspEnabled(config))
+        return false;
+    if (config && typeof config === "object" && config[id]?.disabled)
+        return false;
+    return true;
+}
+export function isTypeScriptLspEnabled(config) {
+    return isLspServerEnabled(config, "typescript");
+}
+export function customLspServerEntries(config) {
+    if (!config || typeof config !== "object")
+        return [];
+    return Object.entries(config).filter(([id, server]) => !BUILTIN_LSP_SERVER_IDS.includes(id)
+        && Array.isArray(server.command)
+        && server.command.length > 0
+        && Array.isArray(server.extensions)
+        && server.extensions.length > 0);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}

package/dist/lsp/diagnostics.d.ts

@@ -0,0 +1,24 @@
+export interface LspDiagnostic {
+    range?: {
+        start?: {
+            line?: number;
+            character?: number;
+        };
+        end?: {
+            line?: number;
+            character?: number;
+        };
+    };
+    severity?: number;
+    code?: string | number;
+    source?: string;
+    message: string;
+}
+export interface FormatDiagnosticsOptions {
+    max?: number;
+    includeSummary?: boolean;
+}
+export declare function formatDiagnostics(filePath: string, diagnostics: LspDiagnostic[], cwd?: string, options?: FormatDiagnosticsOptions): string;
+export declare function formatDiagnosticBlocks(cwd: string, currentFile: string, diagnostics: Record<string, LspDiagnostic[]>): string;
+export declare function normalizeDiagnostics(diagnostics: LspDiagnostic[]): LspDiagnostic[];
+export declare function formatDiagnosticSummary(diagnostics: LspDiagnostic[]): string;

package/dist/lsp/diagnostics.js

@@ -0,0 +1,103 @@
+import { relative } from "node:path";
+const SEVERITY_LABELS = {
+    1: "error",
+    2: "warning",
+    3: "info",
+    4: "hint",
+};
+const SEVERITY_RANK = {
+    1: 0,
+    2: 1,
+    3: 2,
+    4: 3,
+};
+export function formatDiagnostics(filePath, diagnostics, cwd, options = {}) {
+    const normalized = normalizeDiagnostics(diagnostics);
+    if (!normalized.length)
+        return "";
+    const label = cwd ? relative(cwd, filePath) || "." : filePath;
+    const limit = options.max ?? 20;
+    const lines = normalized.slice(0, limit).map((diagnostic) => {
+        const line = (diagnostic.range?.start?.line ?? 0) + 1;
+        const character = (diagnostic.range?.start?.character ?? 0) + 1;
+        const severity = SEVERITY_LABELS[diagnostic.severity ?? 1] ?? "diagnostic";
+        const source = diagnostic.source ? ` ${diagnostic.source}` : "";
+        const code = diagnostic.code === undefined ? "" : ` [${diagnostic.code}]`;
+        return `- ${label}:${line}:${character} ${severity}${source}${code}: ${diagnostic.message}`;
+    });
+    if (normalized.length > lines.length) {
+        lines.push(`- ... ${normalized.length - lines.length} more diagnostic(s)`);
+    }
+    if (options.includeSummary) {
+        lines.unshift(formatDiagnosticSummary(normalized));
+    }
+    return lines.join("\n");
+}
+export function formatDiagnosticBlocks(cwd, currentFile, diagnostics) {
+    let output = "";
+    let otherFiles = 0;
+    for (const [file, issues] of sortDiagnosticEntries(diagnostics, currentFile)) {
+        const normalized = normalizeDiagnostics(issues);
+        if (!normalized.length)
+            continue;
+        if (file === currentFile) {
+            output += `\n\nLSP diagnostics in this file:\n${formatDiagnostics(file, normalized, cwd, { includeSummary: true })}`;
+            continue;
+        }
+        if (otherFiles >= 5)
+            continue;
+        otherFiles += 1;
+        output += `\n\nLSP diagnostics in other files:\n${formatDiagnostics(file, normalized, cwd, { includeSummary: true })}`;
+    }
+    return output;
+}
+export function normalizeDiagnostics(diagnostics) {
+    const byKey = new Map();
+    for (const diagnostic of diagnostics) {
+        const key = [
+            diagnostic.range?.start?.line ?? 0,
+            diagnostic.range?.start?.character ?? 0,
+            diagnostic.severity ?? 1,
+            diagnostic.source ?? "",
+            diagnostic.code ?? "",
+            diagnostic.message,
+        ].join("|");
+        if (!byKey.has(key))
+            byKey.set(key, diagnostic);
+    }
+    return [...byKey.values()].sort(compareDiagnostic);
+}
+export function formatDiagnosticSummary(diagnostics) {
+    const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+    for (const diagnostic of diagnostics) {
+        const label = SEVERITY_LABELS[diagnostic.severity ?? 1] ?? "error";
+        if (label in counts)
+            counts[label] += 1;
+    }
+    const parts = [
+        counts.error ? `${counts.error} error${counts.error === 1 ? "" : "s"}` : "",
+        counts.warning ? `${counts.warning} warning${counts.warning === 1 ? "" : "s"}` : "",
+        counts.info ? `${counts.info} info` : "",
+        counts.hint ? `${counts.hint} hint${counts.hint === 1 ? "" : "s"}` : "",
+    ].filter(Boolean);
+    return parts.length ? `Summary: ${parts.join(", ")}` : "Summary: no diagnostics";
+}
+function sortDiagnosticEntries(diagnostics, currentFile) {
+    return Object.entries(diagnostics).sort(([fileA, issuesA], [fileB, issuesB]) => {
+        if (fileA === currentFile && fileB !== currentFile)
+            return -1;
+        if (fileB === currentFile && fileA !== currentFile)
+            return 1;
+        return strongestSeverity(issuesA) - strongestSeverity(issuesB) || fileA.localeCompare(fileB);
+    });
+}
+function strongestSeverity(diagnostics) {
+    return Math.min(...diagnostics.map((diagnostic) => SEVERITY_RANK[diagnostic.severity ?? 1] ?? 99), 99);
+}
+function compareDiagnostic(a, b) {
+    return (SEVERITY_RANK[a.severity ?? 1] ?? 99) - (SEVERITY_RANK[b.severity ?? 1] ?? 99)
+        || (a.range?.start?.line ?? 0) - (b.range?.start?.line ?? 0)
+        || (a.range?.start?.character ?? 0) - (b.range?.start?.character ?? 0)
+        || (a.source ?? "").localeCompare(b.source ?? "")
+        || a.message.localeCompare(b.message);
+}

package/dist/lsp/index.d.ts

@@ -0,0 +1,3 @@
+export { formatDiagnosticBlocks, formatDiagnosticSummary, formatDiagnostics, normalizeDiagnostics, type FormatDiagnosticsOptions, type LspDiagnostic, } from "./diagnostics.js";
+export { isLspEnabled, isTypeScriptLspEnabled, normalizeLspConfig, type LspConfig, type LspServerConfig, } from "./config.js";
+export { getLspService, TypeScriptLspService, type LspLocationInput, type LspService, type LspStatus, } from "./service.js";

package/dist/lsp/index.js

@@ -0,0 +1,3 @@
+export { formatDiagnosticBlocks, formatDiagnosticSummary, formatDiagnostics, normalizeDiagnostics, } from "./diagnostics.js";
+export { isLspEnabled, isTypeScriptLspEnabled, normalizeLspConfig, } from "./config.js";
+export { getLspService, TypeScriptLspService, } from "./service.js";

package/dist/lsp/service.d.ts

@@ -0,0 +1,85 @@
+import { type LspConfig } from "./config.js";
+import type { LspDiagnostic } from "./diagnostics.js";
+export type LspStatusKind = "starting" | "connected" | "error";
+export interface LspStatus {
+    id: string;
+    name: string;
+    root: string;
+    status: LspStatusKind;
+    message?: string;
+}
+export interface LspLocationInput {
+    file: string;
+    line: number;
+    character: number;
+}
+export interface LspService {
+    onStatusChange(listener: () => void): () => void;
+    isDisabled(): boolean;
+    updateConfig(config?: LspConfig): void;
+    status(): LspStatus[];
+    hasClients(filePath: string): Promise<boolean>;
+    touchFile(filePath: string, diagnostics?: "document" | "full"): Promise<void>;
+    diagnostics(): Record<string, LspDiagnostic[]>;
+    restart(): Promise<void>;
+    hover(input: LspLocationInput): Promise<unknown[]>;
+    definition(input: LspLocationInput): Promise<unknown[]>;
+    references(input: LspLocationInput): Promise<unknown[]>;
+    implementation(input: LspLocationInput): Promise<unknown[]>;
+    documentSymbol(filePath: string): Promise<unknown[]>;
+    workspaceSymbol(query: string): Promise<unknown[]>;
+    prepareCallHierarchy(input: LspLocationInput): Promise<unknown[]>;
+    incomingCalls(input: LspLocationInput): Promise<unknown[]>;
+    outgoingCalls(input: LspLocationInput): Promise<unknown[]>;
+}
+export declare class ProjectLspService implements LspService {
+    private readonly cwd;
+    private readonly emitter;
+    private readonly clients;
+    private readonly spawning;
+    private readonly starting;
+    private readonly broken;
+    private readonly unavailable;
+    private readonly diagnosticsByFile;
+    private readonly waiters;
+    private disposed;
+    private config;
+    constructor(cwd: string, config?: LspConfig);
+    updateConfig(config?: LspConfig): void;
+    restart(): Promise<void>;
+    onStatusChange(listener: () => void): () => void;
+    isDisabled(): boolean;
+    status(): LspStatus[];
+    hasClients(filePath: string): Promise<boolean>;
+    touchFile(filePath: string, diagnostics?: "document" | "full"): Promise<void>;
+    diagnostics(): Record<string, LspDiagnostic[]>;
+    hover(input: LspLocationInput): Promise<unknown[]>;
+    definition(input: LspLocationInput): Promise<unknown[]>;
+    references(input: LspLocationInput): Promise<unknown[]>;
+    implementation(input: LspLocationInput): Promise<unknown[]>;
+    documentSymbol(filePath: string): Promise<unknown[]>;
+    workspaceSymbol(query: string): Promise<unknown[]>;
+    prepareCallHierarchy(input: LspLocationInput): Promise<unknown[]>;
+    incomingCalls(input: LspLocationInput): Promise<unknown[]>;
+    outgoingCalls(input: LspLocationInput): Promise<unknown[]>;
+    shutdown(): Promise<void>;
+    shutdownNow(): void;
+    private runRequest;
+    private callHierarchyRequest;
+    private getClients;
+    private getClient;
+    private spawnClient;
+    private openOrChange;
+    private waitForDiagnostics;
+    private resolveDiagnosticWaiters;
+    private matchingServers;
+    private servers;
+    private markBroken;
+    private emitStatus;
+    private resolveInsideCwd;
+    private shutdownClient;
+    private shutdownClients;
+    private shutdownDisabledClients;
+}
+export declare const TypeScriptLspService: typeof ProjectLspService;
+export declare function getLspService(cwd: string, config?: LspConfig): ProjectLspService;