@likec4/language-server 1.46.4 → 1.48.0

package/dist/mcp/server/WithMCPServer.js

@@ -1,54 +0,0 @@
-import { loggable } from '@likec4/log';
-import { logger } from '../utils';
-import { StdioLikeC4MCPServer } from './StdioLikeC4MCPServer';
-import { StreamableLikeC4MCPServer } from './StreamableLikeC4MCPServer';
-const streamableLikeC4MCPServer = (services, defaultPort = 33335) => {
-    logger.debug('Creating StreamableLikeC4MCPServer');
-    const server = new StreamableLikeC4MCPServer(services, defaultPort);
-    const langId = services.LanguageMetaData.languageId;
-    const connection = services.shared.lsp.Connection;
-    services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
-        if (update.section !== langId) {
-            logger.warn('Unexpected configuration update: {update}', { update });
-            return;
-        }
-        const { enabled = false, port = defaultPort, } = update.configuration.mcp;
-        if (!enabled) {
-            void server.stop();
-            return;
-        }
-        void Promise.resolve()
-            .then(() => server.start(port))
-            .then(() => {
-            connection?.telemetry?.logEvent({
-                eventName: 'mcp-server-started',
-                mcpPort: port,
-            });
-        })
-            .catch(err => {
-            const message = loggable(err);
-            connection?.telemetry?.logEvent({
-                eventName: 'mcp-server-start-failed',
-                mcpPort: port,
-                message,
-            });
-            logger.warn(`Failed to start LikeC4 MCP Server: \n${message}`);
-            if (connection) {
-                connection.window.showErrorMessage(`LikeC4: Failed to start MCP Server\n\n${message}`);
-            }
-        });
-    });
-    return server;
-};
-const stdioLikeC4MCPServer = (services) => {
-    return new StdioLikeC4MCPServer(services);
-};
-export const WithMCPServer = (type = 'sse') => ({
-    mcpServer: (services) => {
-        if (type === 'stdio') {
-            return stdioLikeC4MCPServer(services);
-        }
-        const port = typeof type === 'object' ? type.port : 33335;
-        return streamableLikeC4MCPServer(services, port);
-    },
-});

package/dist/mcp/tools/_common.d.ts

@@ -1,88 +0,0 @@
-import type { LikeC4ViewModel } from '@likec4/core/model';
-import type { ProjectId } from '@likec4/core/types';
-import * as z from 'zod/v3';
-import type { LikeC4LanguageServices } from '../../LikeC4LanguageServices';
-import type { Locate } from '../../protocol';
-export declare const locationSchema: z.ZodNullable<z.ZodObject<{
-    path: z.ZodString;
-    range: z.ZodObject<{
-        start: z.ZodObject<{
-            line: z.ZodNumber;
-            character: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            line: number;
-            character: number;
-        }, {
-            line: number;
-            character: number;
-        }>;
-        end: z.ZodObject<{
-            line: z.ZodNumber;
-            character: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            line: number;
-            character: number;
-        }, {
-            line: number;
-            character: number;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        start: {
-            line: number;
-            character: number;
-        };
-        end: {
-            line: number;
-            character: number;
-        };
-    }, {
-        start: {
-            line: number;
-            character: number;
-        };
-        end: {
-            line: number;
-            character: number;
-        };
-    }>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    range: {
-        start: {
-            line: number;
-            character: number;
-        };
-        end: {
-            line: number;
-            character: number;
-        };
-    };
-}, {
-    path: string;
-    range: {
-        start: {
-            line: number;
-            character: number;
-        };
-        end: {
-            line: number;
-            character: number;
-        };
-    };
-}>>;
-export declare const projectIdSchema: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
-export declare const includedInViewsSchema: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    type: z.ZodEnum<["element", "deployment", "dynamic"]>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    title: string;
-    type: "deployment" | "element" | "dynamic";
-}, {
-    id: string;
-    title: string;
-    type: "deployment" | "element" | "dynamic";
-}>, "many">;
-export declare const includedInViews: (views: Iterable<LikeC4ViewModel>) => z.infer<typeof includedInViewsSchema>;
-export declare const mkLocate: (languageServices: LikeC4LanguageServices, projectId: string) => (params: Locate.Params) => z.infer<typeof locationSchema>;

package/dist/mcp/tools/_common.js

@@ -1,49 +0,0 @@
-import { URI } from 'vscode-uri';
-import * as z from 'zod/v3';
-import { ProjectsManager } from '../../workspace';
-import { logger } from '../utils';
-export const locationSchema = z.object({
-    path: z.string().describe('Path to the file'),
-    range: z.object({
-        start: z.object({
-            line: z.number(),
-            character: z.number(),
-        }),
-        end: z.object({
-            line: z.number(),
-            character: z.number(),
-        }),
-    }).describe('Range in the file'),
-}).nullable();
-export const projectIdSchema = z.string()
-    .refine((_v) => true)
-    .optional()
-    .default(ProjectsManager.DefaultProjectId)
-    .describe('Project id (optional, will use "default" if not specified)');
-export const includedInViewsSchema = z.array(z.object({
-    id: z.string().describe('View id'),
-    title: z.string().describe('View title'),
-    type: z.enum(['element', 'deployment', 'dynamic']).describe('View type'),
-}));
-export const includedInViews = (views) => {
-    return [...views].map(v => ({
-        id: v.id,
-        title: v.titleOrId,
-        type: v.$view._type,
-    }));
-};
-export const mkLocate = (languageServices, projectId) => (params) => {
-    try {
-        const loc = languageServices.locate({ projectId, ...params });
-        return loc
-            ? {
-                path: URI.parse(loc.uri).fsPath,
-                range: loc.range,
-            }
-            : null;
-    }
-    catch (e) {
-        logger.debug(`Failed to locate {params}`, { error: e, params });
-        return null;
-    }
-};

package/dist/mcp/tools/find-relationships.d.ts

@@ -1,12 +0,0 @@
-import * as z from 'zod/v3';
-export declare const findRelationships: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: {
-        element1: z.ZodString;
-        element2: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
-    };
-}, (args: {
-    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
-    element1: string;
-    element2: string;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/find-relationships.js

@@ -1,150 +0,0 @@
-import { modelConnection } from '@likec4/core/model';
-import { invariant, isSameHierarchy } from '@likec4/core/utils';
-import * as z from 'zod/v3';
-import { likec4Tool } from '../utils';
-import { includedInViews, includedInViewsSchema, locationSchema, mkLocate, projectIdSchema } from './_common';
-const endpointSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    kind: z.string(),
-});
-const searchResultSchema = z.object({
-    type: z.enum(['direct', 'indirect']).describe('Type of relationship, "direct" for direct relationships, "indirect" for relationships through nested elements'),
-    source: endpointSchema,
-    target: endpointSchema,
-    kind: z.string().nullable().describe('Relationship kind'),
-    title: z.string().nullable().describe('Relationship title'),
-    description: z.string().nullable().describe('Relationship description'),
-    technology: z.string().nullable().describe('Relationship technology'),
-    tags: z.array(z.string()).describe('Relationship tags'),
-    includedInViews: includedInViewsSchema.describe('Views that include this relationship'),
-    sourceLocation: locationSchema,
-});
-export const findRelationships = likec4Tool({
-    name: 'find-relationships',
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        title: 'Find relationships between two elements',
-    },
-    description: `
-Find relationships between two LikeC4 elements within a project.
-
-What it does:
-- Finds both direct relationships (element1 ↔ element2) and indirect ones that arise via containment (e.g. via nested elements).
-- Returns rich metadata for each relationship and where it appears in views.
-
-Inputs:
-- element1: string — Element ID (FQN)
-- element2: string — Element ID (FQN)
-- project: string (optional, defaults to "default") — Project id
-
-Output:
-- found: Relationship[]
-
-Relationship (object) fields:
-- type: "direct" | "indirect" — direct is between the specified endpoints; indirect is via nested elements
-- source: Endpoint
-- target: Endpoint
-- kind: string|null — relationship kind from the model
-- title: string|null — relationship title if provided
-- description: string|null — relationship description text
-- technology: string|null — relationship technology
-- tags: string[] — relationship tags
-- includedInViews: View[] — views where this relationship appears
-- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null
-
-Endpoint (object) fields:
-- id: string — Element ID (FQN)
-- title: string — element title
-- kind: string — element kind
-
-View (object) fields:
-- id: string — view identifier
-- title: string — view title
-- type: "element" | "deployment" | "dynamic"
-
-Notes:
-- Read-only, idempotent; does not mutate the model. May trigger UI navigation in supporting clients.
-- The order of results is not guaranteed.
-
-Example:
-Request:
-{
-  "element1": "shop.frontend",
-  "element2": "shop.backend",
-  "project": "default"
-}
-
-Response:
-{
-  "found": [
-    {
-      "type": "direct",
-      "source": { "id": "shop.frontend", "title": "Frontend", "kind": "component" },
-      "target": { "id": "shop.backend", "title": "Backend", "kind": "component" },
-      "kind": "sync",
-      "title": "Calls",
-      "description": "Frontend calls Backend",
-      "technology": "HTTP",
-      "tags": ["public"],
-      "includedInViews": [
-        { "id": "system-overview", "title": "System Overview", "type": "element" }
-      ],
-      "sourceLocation": {
-        "path": "/abs/path/project/model.c4",
-        "range": { "start": { "line": 12, "character": 0 }, "end": { "line": 14, "character": 0 } }
-      }
-    }
-  ]
-}
-`,
-    inputSchema: {
-        element1: z.string().describe('Element ID (FQN)'),
-        element2: z.string().describe('Element ID (FQN)'),
-        project: projectIdSchema,
-    },
-    outputSchema: {
-        found: z.array(searchResultSchema),
-    },
-}, async (languageServices, args) => {
-    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
-    if (isSameHierarchy(args.element1, args.element2)) {
-        throw new Error('No relationships possible between parent-child');
-    }
-    const found = [];
-    const model = await languageServices.computedModel(projectId);
-    const el1 = model.findElement(args.element1);
-    invariant(el1, `Element "${args.element1}" not found in project "${projectId}"`);
-    const el2 = model.findElement(args.element2);
-    invariant(el2, `Element "${args.element2}" not found in project "${projectId}"`);
-    const locate = mkLocate(languageServices, projectId);
-    const relationships = modelConnection.findConnection(el1, el2, 'both').flatMap(c => [...c.relations]);
-    for (const relationship of relationships) {
-        const isDirect = (relationship.source === el1 && relationship.target === el2)
-            || (relationship.source === el2 && relationship.target === el1);
-        found.push({
-            type: isDirect ? 'direct' : 'indirect',
-            source: {
-                id: relationship.source.id,
-                title: relationship.source.title,
-                kind: relationship.source.kind,
-            },
-            target: {
-                id: relationship.target.id,
-                title: relationship.target.title,
-                kind: relationship.target.kind,
-            },
-            kind: relationship.kind,
-            title: relationship.title,
-            description: relationship.description.text,
-            technology: relationship.technology,
-            tags: [...relationship.tags],
-            includedInViews: includedInViews(relationship.views()),
-            sourceLocation: locate({ relation: relationship.id }),
-        });
-    }
-    return {
-        found,
-    };
-});

package/dist/mcp/tools/list-projects.d.ts

@@ -1,6 +0,0 @@
-import * as z from 'zod/v3';
-export declare const listProjects: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: z.ZodRawShape;
-}, (args: {
-    [x: string]: any;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/list-projects.js

@@ -1,62 +0,0 @@
-import * as z from 'zod/v3';
-import { likec4Tool } from '../utils';
-export const listProjects = likec4Tool({
-    name: 'list-projects',
-    description: `
-List LikeC4 projects discoverable in the current workspace.
-
-Request:
-- No input parameters.
-
-Response (JSON object):
-- projects: Project[]
-
-Project (object) fields:
-- id: string — stable project identifier
-- title: string — human-readable project title
-- folder: string — absolute path to the project root
-- sources: string[] — absolute file paths of related documents
-
-Notes:
-- Read-only, idempotent, no side effects.
-- Safe to call repeatedly.
-
-Example response:
-{
-  "projects": [
-    {
-      "id": "docs",
-      "title": "Documentation",
-      "folder": "/abs/path/to/workspace/docs",
-      "sources": [
-        "/abs/path/to/workspace/docs/model/contexts.likec4",
-        "/abs/path/to/workspace/docs/model/relations.likec4"
-      ]
-    }
-  ]
-}
-`,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        title: 'List projects',
-    },
-    outputSchema: {
-        projects: z.array(z.object({
-            id: z.string(),
-            title: z.string(),
-            folder: z.string(),
-            sources: z.array(z.string()),
-        })),
-    },
-}, async (languageServices) => {
-    const projects = languageServices.projects();
-    return {
-        projects: projects.map(p => ({
-            id: p.id,
-            title: p.title,
-            folder: p.folder.fsPath,
-            sources: p.documents.map(d => d.fsPath),
-        })),
-    };
-});

package/dist/mcp/tools/open-view.d.ts

@@ -1,10 +0,0 @@
-import * as z from 'zod/v3';
-export declare const openView: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: {
-        viewId: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
-    };
-}, (args: {
-    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
-    viewId: string;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/open-view.js

@@ -1,52 +0,0 @@
-import * as z from 'zod/v3';
-import { likec4Tool } from '../utils';
-import { locationSchema, mkLocate, projectIdSchema } from './_common';
-export const openView = likec4Tool({
-    name: 'open-view',
-    description: `
-Open a LikeC4 view in the editor's preview panel.
-
-Request:
-- viewId: string — view id (name)
-- project: string (optional) — project id. Defaults to "default" if omitted.
-
-Response (JSON object):
-- location: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null — source location of the view if available
-
-Notes:
-- Read-only and idempotent with respect to the project model. Triggers a UI action in the editor.
-- Only one preview panel can be open at a time.
-
-Example response:
-{
-  "location": {
-    "path": "/abs/path/project/model.c4",
-    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 30, "character": 0 } }
-  }
-}
-`,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        title: 'Open view in preview panel',
-    },
-    inputSchema: {
-        viewId: z.string().describe('View id (name)'),
-        project: projectIdSchema,
-    },
-    outputSchema: {
-        location: locationSchema,
-    },
-}, async (languageServices, args) => {
-    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
-    const model = await languageServices.computedModel(projectId);
-    const view = model.findView(args.viewId);
-    if (!view) {
-        throw new Error(`View with ID '${args.viewId}' not found in project ${projectId}`);
-    }
-    await languageServices.views.openView(view.id, projectId);
-    const locate = mkLocate(languageServices, projectId);
-    return {
-        location: locate({ view: view.id }),
-    };
-});

package/dist/mcp/tools/read-deployment.d.ts

@@ -1,10 +0,0 @@
-import * as z from 'zod/v3';
-export declare const readDeployment: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: {
-        id: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
-    };
-}, (args: {
-    id: string;
-    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/read-deployment.js

@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { invariant } from '@likec4/core';
-import * as z from 'zod/v3';
-import { likec4Tool } from '../utils';
-import { includedInViews, includedInViewsSchema, locationSchema, mkLocate, projectIdSchema } from './_common';
-export const readDeployment = likec4Tool({
-    name: 'read-deployment',
-    description: `
-Read details about a deployment node or a deployed instance in a LikeC4 project.
-
-What it does:
-- Returns metadata about a deployment entity (node or instance), including kind, tags, color/shape, children, which views include it, and its source location.
-
-Inputs:
-- id: string — Deployment id (FQN)
-- project: string (optional, defaults to "default") — Project id
-
-Output fields:
-- type: "deployment-node" | "deployed-instance"
-- id: string — Deployment id (FQN)
-- kind: string — Deployment node kind, or element kind for deployed instances
-- name: string — Name of the deployment entity
-- title: string — Title of the deployment entity
-- description: string|null — Description text
-- technology: string|null — Technology info, if any
-- tags: string[] — Tags assigned to this entity
-- project: string — Project id
-- metadata: Record<string, string>
-- links: Array<{ title: string|null, url: string, relative: string|null }> — external links associated with this deployment entity
-- shape: string — Rendered shape
-- color: string — Rendered color
-- children: string[] — Child deployment ids (empty for instances)
-- includedInViews: View[] — Views that include this entity
-- instanceof: { id: string, title: string, kind: string } | null — If type is "deployed-instance", the referenced element
-- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null
-
-View (object) fields:
-- id: string — view identifier
-- title: string — view title
-- type: "element" | "deployment" | "dynamic"
-
-Notes:
-- Read-only, idempotent; does not mutate the model.
-
-Example request:
-{ "id": "k8s.cluster.frontend", "project": "default" }
-
-Example response (deployed instance):
-{
-  "type": "deployed-instance",
-  "id": "k8s.cluster.frontend",
-  "kind": "k8s.pod",
-  "name": "frontend",
-  "title": "Frontend Pod",
-  "description": null,
-  "technology": "Kubernetes",
-  "tags": ["prod"],
-  "project": "default",
-  "metadata": {},
-  "links": [],
-  "shape": "rectangle",
-  "color": "#2F80ED",
-  "children": [],
-  "includedInViews": [
-    { "id": "runtime-overview", "title": "Runtime Overview", "type": "deployment" }
-  ],
-  "instanceof": { "id": "shop.frontend", "title": "Frontend", "kind": "component" },
-  "sourceLocation": {
-    "path": "/abs/path/project/model.c4",
-    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 25, "character": 0 } }
-  }
-}
-`,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        title: 'Read deployment entity',
-    },
-    inputSchema: {
-        id: z.string().describe('Deployment id (FQN)'),
-        project: projectIdSchema,
-    },
-    outputSchema: {
-        type: z.enum(['deployment-node', 'deployed-instance']),
-        id: z.string().describe('Deployment id (FQN)'),
-        kind: z.string().describe('Deployment node kind, or element kind for deployed instances'),
-        name: z.string(),
-        title: z.string(),
-        description: z.string().nullable(),
-        technology: z.string().nullable(),
-        tags: z.array(z.string()),
-        project: z.string(),
-        metadata: z.record(z.union([z.string(), z.array(z.string())])),
-        links: z.array(z.object({
-            title: z.string().nullable().describe('Optional link title'),
-            url: z.string().describe('Link URL'),
-            relative: z.string().nullable().describe('Relative path (if URL is relative to workspace root)'),
-        })).describe('External links associated with this deployment entity'),
-        shape: z.string(),
-        color: z.string(),
-        children: z.array(z.string()).describe('Children of this deployment node (Array of Deployment ids)'),
-        includedInViews: includedInViewsSchema.describe('Views that include this deployment node'),
-        instanceof: z.object({
-            id: z.string().describe('Element ID (FQN)'),
-            title: z.string(),
-            kind: z.string(),
-        }).nullable().describe('If type is "deployed-instance", the referenced element'),
-        sourceLocation: locationSchema,
-    },
-}, async (languageServices, args) => {
-    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
-    const model = await languageServices.computedModel(projectId);
-    const element = model.deployment.findElement(args.id);
-    invariant(element, `Deployment entity "${args.id}" not found in project "${projectId}"`);
-    const locate = mkLocate(languageServices, projectId);
-    return {
-        type: element.isInstance() ? 'deployed-instance' : 'deployment-node',
-        id: element.id,
-        name: element.name,
-        kind: element.kind,
-        title: element.title,
-        description: element.description.text,
-        technology: element.technology,
-        tags: [...element.tags],
-        project: projectId,
-        metadata: element.getMetadata(),
-        links: (element.links ?? []).map(link => ({
-            title: link.title ?? null,
-            url: link.url,
-            relative: link.relative ?? null,
-        })),
-        shape: element.shape,
-        color: element.color,
-        children: element.isInstance() ? [] : [...element.children()].map(c => c.id),
-        includedInViews: includedInViews(element.views()),
-        instanceof: element.isInstance()
-            ? {
-                id: element.element.id,
-                title: element.element.title,
-                kind: element.element.kind,
-            }
-            : null,
-        sourceLocation: locate({ deployment: element.id }),
-    };
-});

package/dist/mcp/tools/read-element.d.ts

@@ -1,10 +0,0 @@
-import * as z from 'zod/v3';
-export declare const readElement: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: {
-        id: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
-    };
-}, (args: {
-    id: string;
-    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];