@latentforce/latentgraph 1.0.0

package/build/mcp-server.js

@@ -0,0 +1,484 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from 'zod';
+import { createRequire } from 'module';
+import { getApiKey } from './utils/config.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+const BASE_URL = process.env.SHIFT_BACKEND_URL || "https://dev-shift-lite.latentforce.ai";
+function getApiKeyFromEnv() {
+    return process.env.SHIFT_API_KEY?.trim() || getApiKey();
+}
+function getProjectIdFromEnv() {
+    const projectId = process.env.SHIFT_PROJECT_ID;
+    if (!projectId || projectId.trim() === "") {
+        throw new Error("SHIFT_PROJECT_ID environment variable is not set. " +
+            "Set it to your Shift Lite project UUID, or pass project_id in each tool call.");
+    }
+    return projectId.trim();
+}
+/** Resolve project_id: use tool arg if provided, else fall back to env. */
+function resolveProjectId(args) {
+    const fromArgs = args.project_id?.trim();
+    if (fromArgs)
+        return fromArgs;
+    return getProjectIdFromEnv();
+}
+/** Normalize file paths: backslash → forward slash, strip leading ./ and / */
+function normalizePath(filePath) {
+    let p = filePath.replace(/\\/g, '/');
+    p = p.replace(/^\.\//, '');
+    p = p.replace(/^\//, '');
+    return p;
+}
+function getAuthHeaders() {
+    const apiKey = getApiKeyFromEnv();
+    const headers = { 'Content-Type': 'application/json' };
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    return headers;
+}
+function handleApiError(response, text) {
+    if (response.status === 404) {
+        if (text.includes('Knowledge graph not found') || text.includes('knowledge graph')) {
+            throw new Error("No knowledge graph exists for this project. Run 'lgraph update-drg' to build it.");
+        }
+        if (text.includes('File not found') || text.includes('not found in')) {
+            const pathMatch = text.match(/['"]([^'"]+)['"]/);
+            const filePath = pathMatch ? pathMatch[1] : 'the requested file';
+            throw new Error(`File '${filePath}' not found in knowledge graph. Possible causes:\n` +
+                `  1. The path may be incorrect (check casing and slashes)\n` +
+                `  2. The file was added after the last 'lgraph update-drg'\n` +
+                `  3. The file type is not supported (only JS/TS files are indexed)`);
+        }
+    }
+    throw new Error(`API call failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`);
+}
+/** POST to backend API */
+async function callBackendAPI(endpoint, data) {
+    const response = await fetch(`${BASE_URL}${endpoint}`, {
+        method: 'POST',
+        headers: getAuthHeaders(),
+        body: JSON.stringify(data),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        handleApiError(response, text);
+    }
+    return await response.json();
+}
+/** GET from backend API with query params */
+async function callBackendAPIGet(endpoint, params) {
+    const qs = new URLSearchParams(params).toString();
+    const url = `${BASE_URL}${endpoint}${qs ? `?${qs}` : ''}`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: getAuthHeaders(),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        handleApiError(response, text);
+    }
+    return await response.json();
+}
+// ============= FORMATTERS =============
+/** Format file_summary response as readable markdown */
+function formatFileSummary(data) {
+    const lines = [];
+    lines.push(`## File: ${data.path}`);
+    if (data.module_name) {
+        lines.push(`**Module:** ${data.module_name}`);
+    }
+    lines.push('');
+    lines.push('### Summary');
+    lines.push(data.summary || 'No summary available.');
+    if (data.exports && Object.keys(data.exports).length > 0) {
+        lines.push('');
+        lines.push('### Exports');
+        for (const [category, items] of Object.entries(data.exports)) {
+            if (items?.length > 0) {
+                lines.push(`**${category}:** ${items.join(', ')}`);
+            }
+        }
+    }
+    if (data.key_components?.length > 0) {
+        lines.push('');
+        lines.push('### Key Components');
+        for (const comp of data.key_components) {
+            if (typeof comp === 'object' && comp !== null) {
+                const name = comp.name || comp.component || Object.keys(comp)[0] || '';
+                const desc = comp.description || comp.purpose || Object.values(comp)[0] || '';
+                lines.push(`- **${name}**: ${desc}`);
+            }
+            else {
+                lines.push(`- ${comp}`);
+            }
+        }
+    }
+    if (data.internal_state) {
+        lines.push('');
+        lines.push(`**Internal State:** ${data.internal_state}`);
+    }
+    if (data.error_handling) {
+        lines.push(`**Error Handling:** ${data.error_handling}`);
+    }
+    if (data.constraints?.length > 0) {
+        lines.push('');
+        lines.push('### Constraints');
+        for (const c of data.constraints) {
+            lines.push(`- ${c}`);
+        }
+    }
+    if (data.dependencies?.length > 0) {
+        lines.push('');
+        lines.push(`### Dependencies (${data.dependency_count ?? data.dependencies.length} imports)`);
+        for (const dep of data.dependencies) {
+            lines.push(`- ${dep}`);
+        }
+    }
+    if (data.dependents?.length > 0) {
+        lines.push('');
+        lines.push(`### Dependents (${data.dependent_count ?? data.dependents.length} files import this)`);
+        for (const dep of data.dependents) {
+            lines.push(`- ${dep}`);
+        }
+    }
+    if (data.parent_summaries?.length > 0) {
+        lines.push('');
+        lines.push('### Directory Context');
+        for (const parent of data.parent_summaries) {
+            lines.push(`- **${parent.path}**: ${parent.summary}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Format dependency response as readable markdown */
+function formatDependencies(data) {
+    const lines = [];
+    const deps = data.dependencies || [];
+    // edge_details is now a dict of {imports, usage_pattern, data_flow, dependency_summary}
+    const edgeDetails = data.edge_details || {};
+    lines.push(`## Dependencies: ${data.path}`);
+    if (data.module_name) {
+        lines.push(`**Module:** ${data.module_name}`);
+    }
+    lines.push('');
+    // --- Forward dependencies ---
+    if (deps.length === 0) {
+        lines.push('This file has no dependencies.');
+    }
+    else {
+        lines.push(`### Imports (${deps.length} file(s) this file depends on)`);
+        lines.push('');
+        for (const dep of deps) {
+            const edge = edgeDetails[dep];
+            if (edge) {
+                lines.push(`- **${dep}**`);
+                if (edge.usage_pattern)
+                    lines.push(`  - Usage: ${edge.usage_pattern}`);
+                if (edge.data_flow)
+                    lines.push(`  - Data flow: ${edge.data_flow}`);
+                if (edge.imports?.length > 0)
+                    lines.push(`  - Imports: ${edge.imports.join(', ')}`);
+                if (edge.dependency_summary)
+                    lines.push(`  - Summary: ${edge.dependency_summary}`);
+            }
+            else {
+                lines.push(`- **${dep}**`);
+            }
+        }
+    }
+    // --- Reverse dependencies ---
+    const dependents = data.dependents || [];
+    const dependentEdges = data.dependent_edge_details || {};
+    if (dependents.length > 0) {
+        lines.push('');
+        lines.push(`### Dependents (${dependents.length} file(s) that import this file)`);
+        lines.push('');
+        for (const dep of dependents) {
+            const edge = dependentEdges[dep];
+            if (edge) {
+                lines.push(`- **${dep}**`);
+                if (edge.usage_pattern)
+                    lines.push(`  - Usage: ${edge.usage_pattern}`);
+                if (edge.data_flow)
+                    lines.push(`  - Data flow: ${edge.data_flow}`);
+                if (edge.imports?.length > 0)
+                    lines.push(`  - Imports: ${edge.imports.join(', ')}`);
+                if (edge.dependency_summary)
+                    lines.push(`  - Summary: ${edge.dependency_summary}`);
+            }
+            else {
+                lines.push(`- **${dep}**`);
+            }
+        }
+    }
+    // --- Implicit dependencies ---
+    const implicitDeps = data.implicit_dependencies || [];
+    if (implicitDeps.length > 0) {
+        lines.push('');
+        lines.push(`### Implicit / External Dependencies (${implicitDeps.length})`);
+        lines.push('');
+        const implicitEdges = data.implicit_edge_summaries || {};
+        for (const dep of implicitDeps) {
+            const summary = implicitEdges[dep];
+            lines.push(summary ? `- **${dep}**: ${summary}` : `- **${dep}**`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Format blast_radius response as readable markdown */
+function formatBlastRadius(data) {
+    const lines = [];
+    const affected = data.affected_files || [];
+    lines.push(`## Blast Radius: ${data.path}`);
+    if (data.module_name) {
+        lines.push(`**Module:** ${data.module_name}`);
+    }
+    lines.push('');
+    if (affected.length === 0) {
+        lines.push('No other files are affected by changes to this file.');
+    }
+    else {
+        lines.push(`**${affected.length}** file(s) would be affected:`);
+        lines.push('');
+        // Group by level
+        const byLevel = {};
+        for (const file of affected) {
+            const level = file.level || 1;
+            if (!byLevel[level])
+                byLevel[level] = [];
+            byLevel[level].push(file);
+        }
+        const levels = Object.keys(byLevel).map(Number).sort((a, b) => a - b);
+        for (const level of levels) {
+            lines.push(`### ${level === 1 ? 'Level 1 (direct)' : `Level ${level}`}`);
+            for (const file of byLevel[level]) {
+                lines.push(`- **${file.path}**: ${file.summary || 'No summary'}`);
+            }
+            lines.push('');
+        }
+    }
+    // --- Affected clusters ---
+    const clusters = data.cluster_blast_radius || [];
+    if (clusters.length > 0) {
+        lines.push('### Affected Modules/Folders');
+        for (const cluster of clusters) {
+            lines.push(`- **${cluster.path}**: ${cluster.summary}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Format module_summary response as readable markdown */
+function formatModuleSummary(data) {
+    const lines = [];
+    lines.push(`## Module: ${data.module_name}`);
+    if (data.parent_module) {
+        lines.push(`**Parent module:** ${data.parent_module}`);
+    }
+    if (data.child_modules?.length > 0) {
+        lines.push(`**Sub-modules:** ${data.child_modules.join(', ')}`);
+    }
+    if (data.drg_cluster_summary) {
+        lines.push('');
+        lines.push('### Architecture Summary');
+        lines.push(data.drg_cluster_summary);
+    }
+    if (data.drg_cluster_metadata && Object.keys(data.drg_cluster_metadata).length > 0) {
+        const meta = data.drg_cluster_metadata;
+        if (meta.architecture_layers?.length > 0) {
+            lines.push('');
+            lines.push('**Architecture Layers:**');
+            for (const layer of meta.architecture_layers) {
+                lines.push(`- ${layer}`);
+            }
+        }
+        if (meta.technology_stack?.length > 0) {
+            lines.push('');
+            lines.push('**Technology Stack:**');
+            for (const tech of meta.technology_stack) {
+                lines.push(`- ${tech}`);
+            }
+        }
+    }
+    if (data.components?.length > 0) {
+        lines.push('');
+        lines.push(`### Files in this module (${data.components.length})`);
+        for (const comp of data.components) {
+            lines.push(`- ${comp}`);
+        }
+    }
+    if (data.content) {
+        lines.push('');
+        lines.push('### Full Documentation');
+        lines.push(data.content);
+    }
+    return lines.join('\n');
+}
+/** Format project_overview response as readable markdown */
+function formatProjectOverview(data) {
+    const lines = [];
+    lines.push('## Project Overview');
+    lines.push('');
+    if (data.architecture_summary) {
+        lines.push('### Architecture Summary');
+        lines.push(data.architecture_summary);
+        lines.push('');
+    }
+    if (data.architecture_layers?.length > 0) {
+        lines.push('### Architecture Layers');
+        for (const layer of data.architecture_layers) {
+            if (typeof layer === 'string') {
+                lines.push(`- ${layer}`);
+            }
+            else if (layer && typeof layer === 'object') {
+                const name = layer.name || layer.layer || layer.title || Object.values(layer)[0];
+                const desc = layer.description || layer.desc || (Object.values(layer).length > 1 ? Object.values(layer)[1] : '');
+                lines.push(desc ? `- **${name}**: ${desc}` : `- ${name}`);
+            }
+        }
+        lines.push('');
+    }
+    if (data.technology_stack?.length > 0) {
+        lines.push('### Technology Stack');
+        for (const tech of data.technology_stack) {
+            if (typeof tech === 'string') {
+                lines.push(`- ${tech}`);
+            }
+            else if (tech && typeof tech === 'object') {
+                const name = tech.name || tech.technology || tech.title || Object.values(tech)[0];
+                const desc = tech.description || tech.desc || (Object.values(tech).length > 1 ? Object.values(tech)[1] : '');
+                lines.push(desc ? `- **${name}**: ${desc}` : `- ${name}`);
+            }
+        }
+        lines.push('');
+    }
+    if (data.entry_points?.length > 0) {
+        lines.push('### Entry Points');
+        for (const ep of data.entry_points) {
+            if (typeof ep === 'string') {
+                lines.push(`- ${ep}`);
+            }
+            else if (ep && typeof ep === 'object') {
+                const name = ep.name || ep.file || ep.path || Object.values(ep)[0];
+                const desc = ep.description || ep.desc || (Object.values(ep).length > 1 ? Object.values(ep)[1] : '');
+                lines.push(desc ? `- **${name}**: ${desc}` : `- ${name}`);
+            }
+        }
+        lines.push('');
+    }
+    if (data.constraints?.length > 0) {
+        lines.push('### Constraints');
+        for (const c of data.constraints) {
+            lines.push(`- ${c}`);
+        }
+        lines.push('');
+    }
+    if (data.top_level_modules?.length > 0) {
+        lines.push('### Top-level Modules');
+        lines.push('');
+        for (const mod of data.top_level_modules) {
+            lines.push(`#### ${mod.path}`);
+            lines.push(mod.summary || '');
+            if (mod.files?.length > 0) {
+                lines.push(`Files: ${mod.files.join(', ')}`);
+            }
+            lines.push('');
+        }
+    }
+    if (data.codewiki_overview) {
+        lines.push('### Project Documentation');
+        lines.push(data.codewiki_overview);
+    }
+    return lines.join('\n');
+}
+// ============= MCP SERVER =============
+export async function startMcpServer() {
+    const server = new McpServer({
+        name: "shift",
+        version,
+    });
+    // ---- blast_radius ----
+    server.registerTool("blast_radius", {
+        description: "Use this BEFORE editing or refactoring any source file. Returns every file in the project that imports or depends on the given file, grouped by dependency depth (level 1 = direct importers, level 2 = their importers, etc.). Also returns the affected modules/folders. Use this to understand the full impact of a change before making it. Only works on indexed source files: .js .jsx .ts .tsx .py .java .cpp .cs .go .c .h .css .scss .html — do not call for .json, .yaml, .md or other non-source files.",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file (relative to project root)"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+            level: z.number().optional().describe("Max depth of blast radius (optional)"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/blast-radius', {
+            path: normalizePath(args.file_path),
+            project_id: projectId,
+            ...(args.level != null && { level: args.level }),
+        });
+        return { content: [{ type: "text", text: formatBlastRadius(data) }] };
+    });
+    // ---- dependencies ----
+    server.registerTool("dependencies", {
+        description: "Returns bidirectional dependencies of a source file: what it imports (with usage pattern, data flow, and summary per dependency) AND what imports it (reverse dependencies). Use this to trace data flow, understand module relationships, follow a bug through the call chain, or map out what a file relies on before modifying it. Only works on indexed source files: .js .jsx .ts .tsx .py .java .cpp .cs .go .c .h .css .scss .html — do not call for .json, .yaml, .md or other non-source files.",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/dependency', {
+            path: normalizePath(args.file_path),
+            project_id: projectId,
+        });
+        return { content: [{ type: "text", text: formatDependencies(data) }] };
+    });
+    // ---- file_summary ----
+    server.registerTool("file_summary", {
+        description: "Returns an AI-generated summary of a source file: what it does, its key exports and functions, internal state, error handling, constraints, what it imports, who imports it, and which module it belongs to. Always call this before reading a raw file — it gives you the essential context without having to parse the full source. Use the 'level' parameter to include summaries of parent directories for broader context. Only works on indexed source files: .js .jsx .ts .tsx .py .java .cpp .cs .go .c .h .css .scss .html — for .json, .yaml, .md, or other non-source files, read them directly instead.",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file to summarize"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+            level: z.number().optional().describe("Number of parent directory levels to include (default 0)"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/what-is-this-file', {
+            path: normalizePath(args.file_path),
+            project_id: projectId,
+            level: args.level ?? 0,
+        });
+        return { content: [{ type: "text", text: formatFileSummary(data) }] };
+    });
+    // ---- module_summary ----
+    server.registerTool("module_summary", {
+        description: "Given any file path, returns the full documentation for the module that owns it, the list of files in that module, the corresponding DRG cluster summary and metadata, and parent/child module relationships. Use this after file_summary to get broader module-level context before editing — especially useful when a change may affect an entire module rather than just one file.",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to any file in the module (relative to project root)"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/module-summary', {
+            path: normalizePath(args.file_path),
+            project_id: projectId,
+        });
+        return { content: [{ type: "text", text: formatModuleSummary(data) }] };
+    });
+    // ---- project_overview ----
+    server.registerTool("project_overview", {
+        description: "Returns the highest-level context for the project: architecture summary, layers, tech stack, entry points, constraints, top-level modules with their files, and the project documentation overview. Call this first at the start of a session — before exploring any specific file — to understand the overall structure and where things live.",
+        inputSchema: z.object({
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPIGet('/api/v1/mcp/project-overview', {
+            project_id: projectId,
+        });
+        return { content: [{ type: "text", text: formatProjectOverview(data) }] };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Shift MCP Server running on stdio");
+    if (!process.env.SHIFT_PROJECT_ID) {
+        console.error("Warning: SHIFT_PROJECT_ID is not set. Pass project_id in each tool call, or set the env var.");
+    }
+}

package/build/utils/api-client.js

@@ -0,0 +1,147 @@
+import { API_BASE_URL, API_BASE_URL_ORCH } from './config.js';
+import { getMachineFingerprint } from './machine-id.js';
+/**
+ * Request a guest API key bound to this machine
+ * The backend will:
+ * - Create a new guest key if this machine_id hasn't been seen before
+ * - Return the existing guest key if this machine_id already has one
+ * - Optionally enforce usage limits per machine
+ */
+export async function requestGuestKey() {
+    const fingerprint = getMachineFingerprint();
+    const response = await fetch(`${API_BASE_URL}/api/guest-key`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            machine_id: fingerprint.machine_id,
+            platform: fingerprint.platform,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    return await response.json();
+}
+/**
+ * Fetch available projects for the user
+ * Matching extension's fetchProjects function in api-client.js
+ */
+export async function fetchProjects(apiKey) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.projects || [];
+}
+/**
+ * Send init scan to backend
+ * Matching extension's init-scan API call
+ */
+export async function sendInitScan(apiKey, projectId, payload) {
+    try {
+        // Ensure proper URL construction with leading slash
+        const path = `/api/projects/${projectId}/init-scan`;
+        const url = new URL(path, API_BASE_URL_ORCH).toString();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        // Re-throw for caller to handle; keep stack/context
+        throw error;
+    }
+}
+/**
+ * Send update-drg request to backend
+ * Calls POST /api/v1/mcp/update-drg
+ */
+export async function sendUpdateDrg(apiKey, payload) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/update-drg`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    return await response.json();
+}
+export async function fetchMigrationTemplates(apiKey) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/migration-templates`, {
+        method: 'GET',
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.templates || [];
+}
+export async function createProject(apiKey, params) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects/create`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(params),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.project || data;
+}
+/**
+ * Fetch project indexing/work status
+ * Returns whether the knowledge graph has been built for this project
+ */
+export async function fetchProjectStatus(apiKey, projectId) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects/${projectId}/status`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}