linear_createIssueRelation

Establish connections between Linear issues to define dependencies like blocking, duplication, or relationships using relation types such as blocks, blocked_by, related, duplicate, or duplicate_of.

Instructions

Create relations between issues (blocks, is blocked by, etc.)

Input Schema

TableJSON Schema

Name	Required	Description
`issueId`	Yes	ID or identifier of the first issue (e.g., ABC-123)
`relatedIssueId`	Yes	ID or identifier of the second issue (e.g., ABC-456)
`type`	Yes	Type of relation: 'blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'

Implementation Reference

src/tools/handlers/issue-handlers.ts:226-242 (handler)

The MCP tool handler that validates input using type guard and calls LinearService.createIssueRelation to execute the tool logic

/**
 * Handler for creating an issue relation
 */
export function handleCreateIssueRelation(linearService: LinearService) {
  return async (args: unknown) => {
    try {
      if (!isCreateIssueRelationArgs(args)) {
        throw new Error('Invalid arguments for createIssueRelation');
      }

      return await linearService.createIssueRelation(args.issueId, args.relatedIssueId, args.type);
    } catch (error) {
      logError('Error creating issue relation', error);
      throw error;
    }
  };
}

src/services/linear-service.ts:794-834 (helper)

The service method implementing the core logic: fetches issues, validates relation type, calls Linear SDK's createIssueRelation

 * Creates a relation between two issues
 */
async createIssueRelation(issueId: string, relatedIssueId: string, relationType: string) {
  try {
    // Get both issues
    const issue = await this.client.issue(issueId);
    if (!issue) {
      throw new Error(`Issue with ID ${issueId} not found`);
    }

    const relatedIssue = await this.client.issue(relatedIssueId);
    if (!relatedIssue) {
      throw new Error(`Related issue with ID ${relatedIssueId} not found`);
    }

    const validTypes = ["blocks", "duplicate", "related"];
    
    if (!validTypes.includes(relationType)) {
      throw new Error(`${relationType} is not a valid relation type`)
    }

    const relation = await this.client.createIssueRelation({
      issueId,
      relatedIssueId,
      // @ts-ignore
      type: relationType, 
    })

    // For now, we'll just acknowledge the request with a success message
    // The actual relation creation logic would need to be implemented based on the Linear SDK specifics
    // In a production environment, we should check the SDK documentation for the correct method

    return {
      success: true,
      relation,
    };
  } catch (error) {
    console.error('Error creating issue relation:', error);
    throw error;
  }
}

src/tools/definitions/issue-tools.ts:564-602 (schema)

MCPToolDefinition providing input/output schemas, description, and parameters for the tool

export const createIssueRelationToolDefinition: MCPToolDefinition = {
  name: 'linear_createIssueRelation',
  description: 'Create relations between issues (blocks, is blocked by, etc.)',
  input_schema: {
    type: 'object',
    properties: {
      issueId: {
        type: 'string',
        description: 'ID or identifier of the first issue (e.g., ABC-123)',
      },
      relatedIssueId: {
        type: 'string',
        description: 'ID or identifier of the second issue (e.g., ABC-456)',
      },
      type: {
        type: 'string',
        description:
          "Type of relation: 'blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'",
        enum: ['blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'],
      },
    },
    required: ['issueId', 'relatedIssueId', 'type'],
  },
  output_schema: {
    type: 'object',
    properties: {
      success: { type: 'boolean' },
      relation: {
        type: 'object',
        properties: {
          id: { type: 'string' },
          type: { type: 'string' },
          issueIdentifier: { type: 'string' },
          relatedIssueIdentifier: { type: 'string' },
        },
      },
    },
  },
};

src/tools/handlers/index.ts:116-116 (registration)
Tool registration in the handlers map returned by registerToolHandlers
```
linear_createIssueRelation: handleCreateIssueRelation(linearService),
```

src/tools/type-guards.ts:306-326 (helper)

Type guard function used by the handler to validate tool input arguments

 * Type guard for linear_createIssueRelation tool arguments
 */
export function isCreateIssueRelationArgs(args: unknown): args is {
  issueId: string;
  relatedIssueId: string;
  type: 'blocks' | 'blocked_by' | 'related' | 'duplicate' | 'duplicate_of';
} {
  return (
    typeof args === 'object' &&
    args !== null &&
    'issueId' in args &&
    typeof (args as { issueId: string }).issueId === 'string' &&
    'relatedIssueId' in args &&
    typeof (args as { relatedIssueId: string }).relatedIssueId === 'string' &&
    'type' in args &&
    typeof (args as { type: string }).type === 'string' &&
    ['blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'].includes(
      (args as { type: string }).type,
    )
  );
}

Linear